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 "common/gl_enum_utils.h"
15 #include "libANGLE/Context.h"
16 #include "libANGLE/Context.inl.h"
17 #include "libANGLE/capture/capture_gles_ext_autogen.h"
18 #include "libANGLE/context_private_call_gles_autogen.h"
19 #include "libANGLE/entry_points_utils.h"
20 #include "libANGLE/validationESEXT.h"
21 #include "libGLESv2/global_state.h"
22
23 using namespace gl;
24
25 #include "libANGLE/capture/capture_gles_1_0_autogen.h"
26 #include "libANGLE/capture/capture_gles_2_0_autogen.h"
27 #include "libANGLE/capture/capture_gles_3_0_autogen.h"
28 #include "libANGLE/capture/capture_gles_3_1_autogen.h"
29 #include "libANGLE/capture/capture_gles_3_2_autogen.h"
30 #include "libANGLE/validationES1.h"
31 #include "libANGLE/validationES2.h"
32 #include "libANGLE/validationES3.h"
33 #include "libANGLE/validationES31.h"
34 #include "libANGLE/validationES32.h"
35
36 using namespace gl;
37
38 extern "C" {
39
40 // GL_AMD_performance_monitor
GL_BeginPerfMonitorAMD(GLuint monitor)41 void GL_APIENTRY GL_BeginPerfMonitorAMD(GLuint monitor)
42 {
43 Context *context = GetValidGlobalContext();
44 EVENT(context, GLBeginPerfMonitorAMD, "context = %d, monitor = %u", CID(context), monitor);
45
46 if (context)
47 {
48 SCOPED_SHARE_CONTEXT_LOCK(context);
49 bool isCallValid =
50 (context->skipValidation() ||
51 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
52 context->getMutableErrorSetForValidation(),
53 angle::EntryPoint::GLBeginPerfMonitorAMD) &&
54 ValidateBeginPerfMonitorAMD(context, angle::EntryPoint::GLBeginPerfMonitorAMD,
55 monitor)));
56 if (isCallValid)
57 {
58 context->beginPerfMonitor(monitor);
59 }
60 ANGLE_CAPTURE_GL(BeginPerfMonitorAMD, isCallValid, context, monitor);
61 }
62 else
63 {
64 GenerateContextLostErrorOnCurrentGlobalContext();
65 }
66 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
67 }
68
GL_DeletePerfMonitorsAMD(GLsizei n,GLuint * monitors)69 void GL_APIENTRY GL_DeletePerfMonitorsAMD(GLsizei n, GLuint *monitors)
70 {
71 Context *context = GetValidGlobalContext();
72 EVENT(context, GLDeletePerfMonitorsAMD, "context = %d, n = %d, monitors = 0x%016" PRIxPTR "",
73 CID(context), n, (uintptr_t)monitors);
74
75 if (context)
76 {
77 SCOPED_SHARE_CONTEXT_LOCK(context);
78 bool isCallValid = (context->skipValidation() ||
79 ValidateDeletePerfMonitorsAMD(
80 context, angle::EntryPoint::GLDeletePerfMonitorsAMD, n, monitors));
81 if (isCallValid)
82 {
83 context->deletePerfMonitors(n, monitors);
84 }
85 ANGLE_CAPTURE_GL(DeletePerfMonitorsAMD, isCallValid, context, n, monitors);
86 }
87 else
88 {
89 GenerateContextLostErrorOnCurrentGlobalContext();
90 }
91 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
92 }
93
GL_EndPerfMonitorAMD(GLuint monitor)94 void GL_APIENTRY GL_EndPerfMonitorAMD(GLuint monitor)
95 {
96 Context *context = GetValidGlobalContext();
97 EVENT(context, GLEndPerfMonitorAMD, "context = %d, monitor = %u", CID(context), monitor);
98
99 if (context)
100 {
101 SCOPED_SHARE_CONTEXT_LOCK(context);
102 bool isCallValid =
103 (context->skipValidation() ||
104 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
105 context->getMutableErrorSetForValidation(),
106 angle::EntryPoint::GLEndPerfMonitorAMD) &&
107 ValidateEndPerfMonitorAMD(context, angle::EntryPoint::GLEndPerfMonitorAMD, monitor)));
108 if (isCallValid)
109 {
110 context->endPerfMonitor(monitor);
111 }
112 ANGLE_CAPTURE_GL(EndPerfMonitorAMD, isCallValid, context, monitor);
113 }
114 else
115 {
116 GenerateContextLostErrorOnCurrentGlobalContext();
117 }
118 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
119 }
120
GL_GenPerfMonitorsAMD(GLsizei n,GLuint * monitors)121 void GL_APIENTRY GL_GenPerfMonitorsAMD(GLsizei n, GLuint *monitors)
122 {
123 Context *context = GetValidGlobalContext();
124 EVENT(context, GLGenPerfMonitorsAMD, "context = %d, n = %d, monitors = 0x%016" PRIxPTR "",
125 CID(context), n, (uintptr_t)monitors);
126
127 if (context)
128 {
129 SCOPED_SHARE_CONTEXT_LOCK(context);
130 bool isCallValid = (context->skipValidation() ||
131 ValidateGenPerfMonitorsAMD(
132 context, angle::EntryPoint::GLGenPerfMonitorsAMD, n, monitors));
133 if (isCallValid)
134 {
135 context->genPerfMonitors(n, monitors);
136 }
137 ANGLE_CAPTURE_GL(GenPerfMonitorsAMD, isCallValid, context, n, monitors);
138 }
139 else
140 {
141 GenerateContextLostErrorOnCurrentGlobalContext();
142 }
143 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
144 }
145
GL_GetPerfMonitorCounterDataAMD(GLuint monitor,GLenum pname,GLsizei dataSize,GLuint * data,GLint * bytesWritten)146 void GL_APIENTRY GL_GetPerfMonitorCounterDataAMD(GLuint monitor,
147 GLenum pname,
148 GLsizei dataSize,
149 GLuint *data,
150 GLint *bytesWritten)
151 {
152 Context *context = GetValidGlobalContext();
153 EVENT(context, GLGetPerfMonitorCounterDataAMD,
154 "context = %d, monitor = %u, pname = %s, dataSize = %d, data = 0x%016" PRIxPTR
155 ", bytesWritten = 0x%016" PRIxPTR "",
156 CID(context), monitor, GLenumToString(GLESEnum::AllEnums, pname), dataSize,
157 (uintptr_t)data, (uintptr_t)bytesWritten);
158
159 if (context)
160 {
161 SCOPED_SHARE_CONTEXT_LOCK(context);
162 bool isCallValid = (context->skipValidation() ||
163 ValidateGetPerfMonitorCounterDataAMD(
164 context, angle::EntryPoint::GLGetPerfMonitorCounterDataAMD, monitor,
165 pname, dataSize, data, bytesWritten));
166 if (isCallValid)
167 {
168 context->getPerfMonitorCounterData(monitor, pname, dataSize, data, bytesWritten);
169 }
170 ANGLE_CAPTURE_GL(GetPerfMonitorCounterDataAMD, isCallValid, context, monitor, pname,
171 dataSize, data, bytesWritten);
172 }
173 else
174 {
175 GenerateContextLostErrorOnCurrentGlobalContext();
176 }
177 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
178 }
179
GL_GetPerfMonitorCounterInfoAMD(GLuint group,GLuint counter,GLenum pname,void * data)180 void GL_APIENTRY GL_GetPerfMonitorCounterInfoAMD(GLuint group,
181 GLuint counter,
182 GLenum pname,
183 void *data)
184 {
185 Context *context = GetValidGlobalContext();
186 EVENT(context, GLGetPerfMonitorCounterInfoAMD,
187 "context = %d, group = %u, counter = %u, pname = %s, data = 0x%016" PRIxPTR "",
188 CID(context), group, counter, GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)data);
189
190 if (context)
191 {
192 SCOPED_SHARE_CONTEXT_LOCK(context);
193 bool isCallValid = (context->skipValidation() ||
194 ValidateGetPerfMonitorCounterInfoAMD(
195 context, angle::EntryPoint::GLGetPerfMonitorCounterInfoAMD, group,
196 counter, pname, data));
197 if (isCallValid)
198 {
199 context->getPerfMonitorCounterInfo(group, counter, pname, data);
200 }
201 ANGLE_CAPTURE_GL(GetPerfMonitorCounterInfoAMD, isCallValid, context, group, counter, pname,
202 data);
203 }
204 else
205 {
206 GenerateContextLostErrorOnCurrentGlobalContext();
207 }
208 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
209 }
210
GL_GetPerfMonitorCounterStringAMD(GLuint group,GLuint counter,GLsizei bufSize,GLsizei * length,GLchar * counterString)211 void GL_APIENTRY GL_GetPerfMonitorCounterStringAMD(GLuint group,
212 GLuint counter,
213 GLsizei bufSize,
214 GLsizei *length,
215 GLchar *counterString)
216 {
217 Context *context = GetValidGlobalContext();
218 EVENT(context, GLGetPerfMonitorCounterStringAMD,
219 "context = %d, group = %u, counter = %u, bufSize = %d, length = 0x%016" PRIxPTR
220 ", counterString = 0x%016" PRIxPTR "",
221 CID(context), group, counter, bufSize, (uintptr_t)length, (uintptr_t)counterString);
222
223 if (context)
224 {
225 SCOPED_SHARE_CONTEXT_LOCK(context);
226 bool isCallValid = (context->skipValidation() ||
227 ValidateGetPerfMonitorCounterStringAMD(
228 context, angle::EntryPoint::GLGetPerfMonitorCounterStringAMD, group,
229 counter, bufSize, length, counterString));
230 if (isCallValid)
231 {
232 context->getPerfMonitorCounterString(group, counter, bufSize, length, counterString);
233 }
234 ANGLE_CAPTURE_GL(GetPerfMonitorCounterStringAMD, isCallValid, context, group, counter,
235 bufSize, length, counterString);
236 }
237 else
238 {
239 GenerateContextLostErrorOnCurrentGlobalContext();
240 }
241 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
242 }
243
GL_GetPerfMonitorCountersAMD(GLuint group,GLint * numCounters,GLint * maxActiveCounters,GLsizei counterSize,GLuint * counters)244 void GL_APIENTRY GL_GetPerfMonitorCountersAMD(GLuint group,
245 GLint *numCounters,
246 GLint *maxActiveCounters,
247 GLsizei counterSize,
248 GLuint *counters)
249 {
250 Context *context = GetValidGlobalContext();
251 EVENT(context, GLGetPerfMonitorCountersAMD,
252 "context = %d, group = %u, numCounters = 0x%016" PRIxPTR
253 ", maxActiveCounters = 0x%016" PRIxPTR ", counterSize = %d, counters = 0x%016" PRIxPTR "",
254 CID(context), group, (uintptr_t)numCounters, (uintptr_t)maxActiveCounters, counterSize,
255 (uintptr_t)counters);
256
257 if (context)
258 {
259 SCOPED_SHARE_CONTEXT_LOCK(context);
260 bool isCallValid = (context->skipValidation() ||
261 ValidateGetPerfMonitorCountersAMD(
262 context, angle::EntryPoint::GLGetPerfMonitorCountersAMD, group,
263 numCounters, maxActiveCounters, counterSize, counters));
264 if (isCallValid)
265 {
266 context->getPerfMonitorCounters(group, numCounters, maxActiveCounters, counterSize,
267 counters);
268 }
269 ANGLE_CAPTURE_GL(GetPerfMonitorCountersAMD, isCallValid, context, group, numCounters,
270 maxActiveCounters, counterSize, counters);
271 }
272 else
273 {
274 GenerateContextLostErrorOnCurrentGlobalContext();
275 }
276 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
277 }
278
GL_GetPerfMonitorGroupStringAMD(GLuint group,GLsizei bufSize,GLsizei * length,GLchar * groupString)279 void GL_APIENTRY GL_GetPerfMonitorGroupStringAMD(GLuint group,
280 GLsizei bufSize,
281 GLsizei *length,
282 GLchar *groupString)
283 {
284 Context *context = GetValidGlobalContext();
285 EVENT(context, GLGetPerfMonitorGroupStringAMD,
286 "context = %d, group = %u, bufSize = %d, length = 0x%016" PRIxPTR
287 ", groupString = 0x%016" PRIxPTR "",
288 CID(context), group, bufSize, (uintptr_t)length, (uintptr_t)groupString);
289
290 if (context)
291 {
292 SCOPED_SHARE_CONTEXT_LOCK(context);
293 bool isCallValid = (context->skipValidation() ||
294 ValidateGetPerfMonitorGroupStringAMD(
295 context, angle::EntryPoint::GLGetPerfMonitorGroupStringAMD, group,
296 bufSize, length, groupString));
297 if (isCallValid)
298 {
299 context->getPerfMonitorGroupString(group, bufSize, length, groupString);
300 }
301 ANGLE_CAPTURE_GL(GetPerfMonitorGroupStringAMD, isCallValid, context, group, bufSize, length,
302 groupString);
303 }
304 else
305 {
306 GenerateContextLostErrorOnCurrentGlobalContext();
307 }
308 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
309 }
310
GL_GetPerfMonitorGroupsAMD(GLint * numGroups,GLsizei groupsSize,GLuint * groups)311 void GL_APIENTRY GL_GetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize, GLuint *groups)
312 {
313 Context *context = GetValidGlobalContext();
314 EVENT(context, GLGetPerfMonitorGroupsAMD,
315 "context = %d, numGroups = 0x%016" PRIxPTR ", groupsSize = %d, groups = 0x%016" PRIxPTR
316 "",
317 CID(context), (uintptr_t)numGroups, groupsSize, (uintptr_t)groups);
318
319 if (context)
320 {
321 SCOPED_SHARE_CONTEXT_LOCK(context);
322 bool isCallValid =
323 (context->skipValidation() ||
324 ValidateGetPerfMonitorGroupsAMD(context, angle::EntryPoint::GLGetPerfMonitorGroupsAMD,
325 numGroups, groupsSize, groups));
326 if (isCallValid)
327 {
328 context->getPerfMonitorGroups(numGroups, groupsSize, groups);
329 }
330 ANGLE_CAPTURE_GL(GetPerfMonitorGroupsAMD, isCallValid, context, numGroups, groupsSize,
331 groups);
332 }
333 else
334 {
335 GenerateContextLostErrorOnCurrentGlobalContext();
336 }
337 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
338 }
339
GL_SelectPerfMonitorCountersAMD(GLuint monitor,GLboolean enable,GLuint group,GLint numCounters,GLuint * counterList)340 void GL_APIENTRY GL_SelectPerfMonitorCountersAMD(GLuint monitor,
341 GLboolean enable,
342 GLuint group,
343 GLint numCounters,
344 GLuint *counterList)
345 {
346 Context *context = GetValidGlobalContext();
347 EVENT(context, GLSelectPerfMonitorCountersAMD,
348 "context = %d, monitor = %u, enable = %s, group = %u, numCounters = %d, counterList = "
349 "0x%016" PRIxPTR "",
350 CID(context), monitor, GLbooleanToString(enable), group, numCounters,
351 (uintptr_t)counterList);
352
353 if (context)
354 {
355 SCOPED_SHARE_CONTEXT_LOCK(context);
356 bool isCallValid =
357 (context->skipValidation() ||
358 (ValidatePixelLocalStorageInactive(
359 context->getPrivateState(), context->getMutableErrorSetForValidation(),
360 angle::EntryPoint::GLSelectPerfMonitorCountersAMD) &&
361 ValidateSelectPerfMonitorCountersAMD(
362 context, angle::EntryPoint::GLSelectPerfMonitorCountersAMD, monitor, enable,
363 group, numCounters, counterList)));
364 if (isCallValid)
365 {
366 context->selectPerfMonitorCounters(monitor, enable, group, numCounters, counterList);
367 }
368 ANGLE_CAPTURE_GL(SelectPerfMonitorCountersAMD, isCallValid, context, monitor, enable, group,
369 numCounters, counterList);
370 }
371 else
372 {
373 GenerateContextLostErrorOnCurrentGlobalContext();
374 }
375 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
376 }
377
378 // GL_ANDROID_extension_pack_es31a
379
380 // GL_ANGLE_base_vertex_base_instance
GL_DrawArraysInstancedBaseInstanceANGLE(GLenum mode,GLint first,GLsizei count,GLsizei instanceCount,GLuint baseInstance)381 void GL_APIENTRY GL_DrawArraysInstancedBaseInstanceANGLE(GLenum mode,
382 GLint first,
383 GLsizei count,
384 GLsizei instanceCount,
385 GLuint baseInstance)
386 {
387 Context *context = GetValidGlobalContext();
388 EVENT(context, GLDrawArraysInstancedBaseInstanceANGLE,
389 "context = %d, mode = %s, first = %d, count = %d, instanceCount = %d, baseInstance = %u",
390 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), first, count, instanceCount,
391 baseInstance);
392
393 if (context)
394 {
395 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
396 SCOPED_SHARE_CONTEXT_LOCK(context);
397 bool isCallValid = (context->skipValidation() ||
398 ValidateDrawArraysInstancedBaseInstanceANGLE(
399 context, angle::EntryPoint::GLDrawArraysInstancedBaseInstanceANGLE,
400 modePacked, first, count, instanceCount, baseInstance));
401 if (isCallValid)
402 {
403 context->drawArraysInstancedBaseInstanceANGLE(modePacked, first, count, instanceCount,
404 baseInstance);
405 }
406 ANGLE_CAPTURE_GL(DrawArraysInstancedBaseInstanceANGLE, isCallValid, context, modePacked,
407 first, count, instanceCount, baseInstance);
408 }
409 else
410 {
411 GenerateContextLostErrorOnCurrentGlobalContext();
412 }
413 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
414 }
415
GL_DrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instanceCount,GLint baseVertex,GLuint baseInstance)416 void GL_APIENTRY GL_DrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,
417 GLsizei count,
418 GLenum type,
419 const void *indices,
420 GLsizei instanceCount,
421 GLint baseVertex,
422 GLuint baseInstance)
423 {
424 Context *context = GetValidGlobalContext();
425 EVENT(context, GLDrawElementsInstancedBaseVertexBaseInstanceANGLE,
426 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
427 ", instanceCount = %d, baseVertex = %d, baseInstance = %u",
428 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count,
429 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instanceCount,
430 baseVertex, baseInstance);
431
432 if (context)
433 {
434 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
435 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
436 SCOPED_SHARE_CONTEXT_LOCK(context);
437 bool isCallValid =
438 (context->skipValidation() ||
439 ValidateDrawElementsInstancedBaseVertexBaseInstanceANGLE(
440 context, angle::EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstanceANGLE,
441 modePacked, count, typePacked, indices, instanceCount, baseVertex, baseInstance));
442 if (isCallValid)
443 {
444 context->drawElementsInstancedBaseVertexBaseInstanceANGLE(
445 modePacked, count, typePacked, indices, instanceCount, baseVertex, baseInstance);
446 }
447 ANGLE_CAPTURE_GL(DrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, context,
448 modePacked, count, typePacked, indices, instanceCount, baseVertex,
449 baseInstance);
450 }
451 else
452 {
453 GenerateContextLostErrorOnCurrentGlobalContext();
454 }
455 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
456 }
457
GL_MultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,const GLuint * baseInstances,GLsizei drawcount)458 void GL_APIENTRY GL_MultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode,
459 const GLint *firsts,
460 const GLsizei *counts,
461 const GLsizei *instanceCounts,
462 const GLuint *baseInstances,
463 GLsizei drawcount)
464 {
465 Context *context = GetValidGlobalContext();
466 EVENT(context, GLMultiDrawArraysInstancedBaseInstanceANGLE,
467 "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR
468 ", instanceCounts = 0x%016" PRIxPTR ", baseInstances = 0x%016" PRIxPTR ", drawcount = %d",
469 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)firsts,
470 (uintptr_t)counts, (uintptr_t)instanceCounts, (uintptr_t)baseInstances, drawcount);
471
472 if (context)
473 {
474 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
475 SCOPED_SHARE_CONTEXT_LOCK(context);
476 bool isCallValid =
477 (context->skipValidation() ||
478 (ValidatePixelLocalStorageInactive(
479 context->getPrivateState(), context->getMutableErrorSetForValidation(),
480 angle::EntryPoint::GLMultiDrawArraysInstancedBaseInstanceANGLE) &&
481 ValidateMultiDrawArraysInstancedBaseInstanceANGLE(
482 context, angle::EntryPoint::GLMultiDrawArraysInstancedBaseInstanceANGLE,
483 modePacked, firsts, counts, instanceCounts, baseInstances, drawcount)));
484 if (isCallValid)
485 {
486 context->multiDrawArraysInstancedBaseInstance(modePacked, firsts, counts,
487 instanceCounts, baseInstances, drawcount);
488 }
489 ANGLE_CAPTURE_GL(MultiDrawArraysInstancedBaseInstanceANGLE, isCallValid, context,
490 modePacked, firsts, counts, instanceCounts, baseInstances, drawcount);
491 }
492 else
493 {
494 GenerateContextLostErrorOnCurrentGlobalContext();
495 }
496 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
497 }
498
499 void GL_APIENTRY
GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,const GLsizei * counts,GLenum type,const void * const * indices,const GLsizei * instanceCounts,const GLint * baseVertices,const GLuint * baseInstances,GLsizei drawcount)500 GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,
501 const GLsizei *counts,
502 GLenum type,
503 const void *const *indices,
504 const GLsizei *instanceCounts,
505 const GLint *baseVertices,
506 const GLuint *baseInstances,
507 GLsizei drawcount)
508 {
509 Context *context = GetValidGlobalContext();
510 EVENT(context, GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE,
511 "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
512 ", instanceCounts = 0x%016" PRIxPTR ", baseVertices = 0x%016" PRIxPTR
513 ", baseInstances = 0x%016" PRIxPTR ", drawcount = %d",
514 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)counts,
515 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices,
516 (uintptr_t)instanceCounts, (uintptr_t)baseVertices, (uintptr_t)baseInstances, drawcount);
517
518 if (context)
519 {
520 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
521 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
522 SCOPED_SHARE_CONTEXT_LOCK(context);
523 bool isCallValid =
524 (context->skipValidation() ||
525 (ValidatePixelLocalStorageInactive(
526 context->getPrivateState(), context->getMutableErrorSetForValidation(),
527 angle::EntryPoint::GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE) &&
528 ValidateMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
529 context,
530 angle::EntryPoint::GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE,
531 modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
532 baseInstances, drawcount)));
533 if (isCallValid)
534 {
535 context->multiDrawElementsInstancedBaseVertexBaseInstance(
536 modePacked, counts, typePacked, indices, instanceCounts, baseVertices,
537 baseInstances, drawcount);
538 }
539 ANGLE_CAPTURE_GL(MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid,
540 context, modePacked, counts, typePacked, indices, instanceCounts,
541 baseVertices, baseInstances, drawcount);
542 }
543 else
544 {
545 GenerateContextLostErrorOnCurrentGlobalContext();
546 }
547 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
548 }
549
550 // GL_ANGLE_client_arrays
551
552 // GL_ANGLE_clip_cull_distance
553
554 // 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)555 void GL_APIENTRY GL_CopyTexture3DANGLE(GLuint sourceId,
556 GLint sourceLevel,
557 GLenum destTarget,
558 GLuint destId,
559 GLint destLevel,
560 GLint internalFormat,
561 GLenum destType,
562 GLboolean unpackFlipY,
563 GLboolean unpackPremultiplyAlpha,
564 GLboolean unpackUnmultiplyAlpha)
565 {
566 Context *context = GetValidGlobalContext();
567 EVENT(context, GLCopyTexture3DANGLE,
568 "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel "
569 "= %d, internalFormat = %d, destType = %s, unpackFlipY = %s, unpackPremultiplyAlpha = "
570 "%s, unpackUnmultiplyAlpha = %s",
571 CID(context), sourceId, sourceLevel, GLenumToString(GLESEnum::AllEnums, destTarget),
572 destId, destLevel, internalFormat, GLenumToString(GLESEnum::AllEnums, destType),
573 GLbooleanToString(unpackFlipY), GLbooleanToString(unpackPremultiplyAlpha),
574 GLbooleanToString(unpackUnmultiplyAlpha));
575
576 if (context)
577 {
578 TextureID sourceIdPacked = PackParam<TextureID>(sourceId);
579 TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget);
580 TextureID destIdPacked = PackParam<TextureID>(destId);
581 SCOPED_SHARE_CONTEXT_LOCK(context);
582 bool isCallValid =
583 (context->skipValidation() ||
584 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
585 context->getMutableErrorSetForValidation(),
586 angle::EntryPoint::GLCopyTexture3DANGLE) &&
587 ValidateCopyTexture3DANGLE(
588 context, angle::EntryPoint::GLCopyTexture3DANGLE, sourceIdPacked, sourceLevel,
589 destTargetPacked, destIdPacked, destLevel, internalFormat, destType, unpackFlipY,
590 unpackPremultiplyAlpha, unpackUnmultiplyAlpha)));
591 if (isCallValid)
592 {
593 context->copyTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
594 destLevel, internalFormat, destType, unpackFlipY,
595 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
596 }
597 ANGLE_CAPTURE_GL(CopyTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel,
598 destTargetPacked, destIdPacked, destLevel, internalFormat, destType,
599 unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
600 }
601 else
602 {
603 GenerateContextLostErrorOnCurrentGlobalContext();
604 }
605 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
606 }
607
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)608 void GL_APIENTRY GL_CopySubTexture3DANGLE(GLuint sourceId,
609 GLint sourceLevel,
610 GLenum destTarget,
611 GLuint destId,
612 GLint destLevel,
613 GLint xoffset,
614 GLint yoffset,
615 GLint zoffset,
616 GLint x,
617 GLint y,
618 GLint z,
619 GLint width,
620 GLint height,
621 GLint depth,
622 GLboolean unpackFlipY,
623 GLboolean unpackPremultiplyAlpha,
624 GLboolean unpackUnmultiplyAlpha)
625 {
626 Context *context = GetValidGlobalContext();
627 EVENT(context, GLCopySubTexture3DANGLE,
628 "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel "
629 "= %d, xoffset = %d, yoffset = %d, zoffset = %d, x = %d, y = %d, z = %d, width = %d, "
630 "height = %d, depth = %d, unpackFlipY = %s, unpackPremultiplyAlpha = %s, "
631 "unpackUnmultiplyAlpha = %s",
632 CID(context), sourceId, sourceLevel, GLenumToString(GLESEnum::AllEnums, destTarget),
633 destId, destLevel, xoffset, yoffset, zoffset, x, y, z, width, height, depth,
634 GLbooleanToString(unpackFlipY), GLbooleanToString(unpackPremultiplyAlpha),
635 GLbooleanToString(unpackUnmultiplyAlpha));
636
637 if (context)
638 {
639 TextureID sourceIdPacked = PackParam<TextureID>(sourceId);
640 TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget);
641 TextureID destIdPacked = PackParam<TextureID>(destId);
642 SCOPED_SHARE_CONTEXT_LOCK(context);
643 bool isCallValid =
644 (context->skipValidation() ||
645 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
646 context->getMutableErrorSetForValidation(),
647 angle::EntryPoint::GLCopySubTexture3DANGLE) &&
648 ValidateCopySubTexture3DANGLE(context, angle::EntryPoint::GLCopySubTexture3DANGLE,
649 sourceIdPacked, sourceLevel, destTargetPacked,
650 destIdPacked, destLevel, xoffset, yoffset, zoffset, x,
651 y, z, width, height, depth, unpackFlipY,
652 unpackPremultiplyAlpha, unpackUnmultiplyAlpha)));
653 if (isCallValid)
654 {
655 context->copySubTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
656 destLevel, xoffset, yoffset, zoffset, x, y, z, width, height,
657 depth, unpackFlipY, unpackPremultiplyAlpha,
658 unpackUnmultiplyAlpha);
659 }
660 ANGLE_CAPTURE_GL(CopySubTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel,
661 destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y,
662 z, width, height, depth, unpackFlipY, unpackPremultiplyAlpha,
663 unpackUnmultiplyAlpha);
664 }
665 else
666 {
667 GenerateContextLostErrorOnCurrentGlobalContext();
668 }
669 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
670 }
671
672 // GL_ANGLE_depth_texture
673
674 // 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)675 void GL_APIENTRY GL_BlitFramebufferANGLE(GLint srcX0,
676 GLint srcY0,
677 GLint srcX1,
678 GLint srcY1,
679 GLint dstX0,
680 GLint dstY0,
681 GLint dstX1,
682 GLint dstY1,
683 GLbitfield mask,
684 GLenum filter)
685 {
686 Context *context = GetValidGlobalContext();
687 EVENT(context, GLBlitFramebufferANGLE,
688 "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, "
689 "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s",
690 CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
691 GLbitfieldToString(GLESEnum::ClearBufferMask, mask).c_str(),
692 GLenumToString(GLESEnum::BlitFramebufferFilter, filter));
693
694 if (context)
695 {
696 SCOPED_SHARE_CONTEXT_LOCK(context);
697 bool isCallValid =
698 (context->skipValidation() ||
699 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
700 context->getMutableErrorSetForValidation(),
701 angle::EntryPoint::GLBlitFramebufferANGLE) &&
702 ValidateBlitFramebufferANGLE(context, angle::EntryPoint::GLBlitFramebufferANGLE,
703 srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
704 mask, filter)));
705 if (isCallValid)
706 {
707 context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
708 filter);
709 }
710 ANGLE_CAPTURE_GL(BlitFramebufferANGLE, isCallValid, context, srcX0, srcY0, srcX1, srcY1,
711 dstX0, dstY0, dstX1, dstY1, mask, filter);
712 }
713 else
714 {
715 GenerateContextLostErrorOnCurrentGlobalContext();
716 }
717 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
718 }
719
720 // GL_ANGLE_framebuffer_multisample
GL_RenderbufferStorageMultisampleANGLE(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)721 void GL_APIENTRY GL_RenderbufferStorageMultisampleANGLE(GLenum target,
722 GLsizei samples,
723 GLenum internalformat,
724 GLsizei width,
725 GLsizei height)
726 {
727 Context *context = GetValidGlobalContext();
728 EVENT(context, GLRenderbufferStorageMultisampleANGLE,
729 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d",
730 CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target), samples,
731 GLenumToString(GLESEnum::InternalFormat, internalformat), width, height);
732
733 if (context)
734 {
735 SCOPED_SHARE_CONTEXT_LOCK(context);
736 bool isCallValid =
737 (context->skipValidation() ||
738 (ValidatePixelLocalStorageInactive(
739 context->getPrivateState(), context->getMutableErrorSetForValidation(),
740 angle::EntryPoint::GLRenderbufferStorageMultisampleANGLE) &&
741 ValidateRenderbufferStorageMultisampleANGLE(
742 context, angle::EntryPoint::GLRenderbufferStorageMultisampleANGLE, target,
743 samples, internalformat, width, height)));
744 if (isCallValid)
745 {
746 context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
747 }
748 ANGLE_CAPTURE_GL(RenderbufferStorageMultisampleANGLE, isCallValid, context, target, samples,
749 internalformat, width, height);
750 }
751 else
752 {
753 GenerateContextLostErrorOnCurrentGlobalContext();
754 }
755 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
756 }
757
758 // GL_ANGLE_get_image
759 void GL_APIENTRY
GL_GetTexImageANGLE(GLenum target,GLint level,GLenum format,GLenum type,void * pixels)760 GL_GetTexImageANGLE(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
761 {
762 Context *context = GetValidGlobalContext();
763 EVENT(context, GLGetTexImageANGLE,
764 "context = %d, target = %s, level = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR
765 "",
766 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level,
767 GLenumToString(GLESEnum::PixelFormat, format), GLenumToString(GLESEnum::PixelType, type),
768 (uintptr_t)pixels);
769
770 if (context)
771 {
772 TextureTarget targetPacked = PackParam<TextureTarget>(target);
773 SCOPED_SHARE_CONTEXT_LOCK(context);
774 bool isCallValid = (context->skipValidation() ||
775 ValidateGetTexImageANGLE(context, angle::EntryPoint::GLGetTexImageANGLE,
776 targetPacked, level, format, type, pixels));
777 if (isCallValid)
778 {
779 context->getTexImage(targetPacked, level, format, type, pixels);
780 }
781 ANGLE_CAPTURE_GL(GetTexImageANGLE, isCallValid, context, targetPacked, level, format, type,
782 pixels);
783 }
784 else
785 {
786 GenerateContextLostErrorOnCurrentGlobalContext();
787 }
788 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
789 }
790
GL_GetCompressedTexImageANGLE(GLenum target,GLint level,void * pixels)791 void GL_APIENTRY GL_GetCompressedTexImageANGLE(GLenum target, GLint level, void *pixels)
792 {
793 Context *context = GetValidGlobalContext();
794 EVENT(context, GLGetCompressedTexImageANGLE,
795 "context = %d, target = %s, level = %d, pixels = 0x%016" PRIxPTR "", CID(context),
796 GLenumToString(GLESEnum::TextureTarget, target), level, (uintptr_t)pixels);
797
798 if (context)
799 {
800 TextureTarget targetPacked = PackParam<TextureTarget>(target);
801 SCOPED_SHARE_CONTEXT_LOCK(context);
802 bool isCallValid = (context->skipValidation() ||
803 ValidateGetCompressedTexImageANGLE(
804 context, angle::EntryPoint::GLGetCompressedTexImageANGLE,
805 targetPacked, level, pixels));
806 if (isCallValid)
807 {
808 context->getCompressedTexImage(targetPacked, level, pixels);
809 }
810 ANGLE_CAPTURE_GL(GetCompressedTexImageANGLE, isCallValid, context, targetPacked, level,
811 pixels);
812 }
813 else
814 {
815 GenerateContextLostErrorOnCurrentGlobalContext();
816 }
817 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
818 }
819
GL_GetRenderbufferImageANGLE(GLenum target,GLenum format,GLenum type,void * pixels)820 void GL_APIENTRY GL_GetRenderbufferImageANGLE(GLenum target,
821 GLenum format,
822 GLenum type,
823 void *pixels)
824 {
825 Context *context = GetValidGlobalContext();
826 EVENT(context, GLGetRenderbufferImageANGLE,
827 "context = %d, target = %s, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
828 CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target),
829 GLenumToString(GLESEnum::PixelFormat, format), GLenumToString(GLESEnum::PixelType, type),
830 (uintptr_t)pixels);
831
832 if (context)
833 {
834 SCOPED_SHARE_CONTEXT_LOCK(context);
835 bool isCallValid = (context->skipValidation() ||
836 ValidateGetRenderbufferImageANGLE(
837 context, angle::EntryPoint::GLGetRenderbufferImageANGLE, target,
838 format, type, pixels));
839 if (isCallValid)
840 {
841 context->getRenderbufferImage(target, format, type, pixels);
842 }
843 ANGLE_CAPTURE_GL(GetRenderbufferImageANGLE, isCallValid, context, target, format, type,
844 pixels);
845 }
846 else
847 {
848 GenerateContextLostErrorOnCurrentGlobalContext();
849 }
850 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
851 }
852
853 // GL_ANGLE_get_serialized_context_string
854
855 // GL_ANGLE_get_tex_level_parameter
GL_GetTexLevelParameterivANGLE(GLenum target,GLint level,GLenum pname,GLint * params)856 void GL_APIENTRY GL_GetTexLevelParameterivANGLE(GLenum target,
857 GLint level,
858 GLenum pname,
859 GLint *params)
860 {
861 Context *context = GetValidGlobalContext();
862 EVENT(context, GLGetTexLevelParameterivANGLE,
863 "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "",
864 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level,
865 GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params);
866
867 if (context)
868 {
869 TextureTarget targetPacked = PackParam<TextureTarget>(target);
870 SCOPED_SHARE_CONTEXT_LOCK(context);
871 bool isCallValid = (context->skipValidation() ||
872 ValidateGetTexLevelParameterivANGLE(
873 context, angle::EntryPoint::GLGetTexLevelParameterivANGLE,
874 targetPacked, level, pname, params));
875 if (isCallValid)
876 {
877 context->getTexLevelParameteriv(targetPacked, level, pname, params);
878 }
879 ANGLE_CAPTURE_GL(GetTexLevelParameterivANGLE, isCallValid, context, targetPacked, level,
880 pname, params);
881 }
882 else
883 {
884 GenerateContextLostErrorOnCurrentGlobalContext();
885 }
886 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
887 }
888
GL_GetTexLevelParameterfvANGLE(GLenum target,GLint level,GLenum pname,GLfloat * params)889 void GL_APIENTRY GL_GetTexLevelParameterfvANGLE(GLenum target,
890 GLint level,
891 GLenum pname,
892 GLfloat *params)
893 {
894 Context *context = GetValidGlobalContext();
895 EVENT(context, GLGetTexLevelParameterfvANGLE,
896 "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "",
897 CID(context), GLenumToString(GLESEnum::AllEnums, target), level,
898 GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params);
899
900 if (context)
901 {
902 TextureTarget targetPacked = PackParam<TextureTarget>(target);
903 SCOPED_SHARE_CONTEXT_LOCK(context);
904 bool isCallValid = (context->skipValidation() ||
905 ValidateGetTexLevelParameterfvANGLE(
906 context, angle::EntryPoint::GLGetTexLevelParameterfvANGLE,
907 targetPacked, level, pname, params));
908 if (isCallValid)
909 {
910 context->getTexLevelParameterfv(targetPacked, level, pname, params);
911 }
912 ANGLE_CAPTURE_GL(GetTexLevelParameterfvANGLE, isCallValid, context, targetPacked, level,
913 pname, params);
914 }
915 else
916 {
917 GenerateContextLostErrorOnCurrentGlobalContext();
918 }
919 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
920 }
921
922 // GL_ANGLE_instanced_arrays
GL_DrawArraysInstancedANGLE(GLenum mode,GLint first,GLsizei count,GLsizei primcount)923 void GL_APIENTRY GL_DrawArraysInstancedANGLE(GLenum mode,
924 GLint first,
925 GLsizei count,
926 GLsizei primcount)
927 {
928 Context *context = GetValidGlobalContext();
929 EVENT(context, GLDrawArraysInstancedANGLE,
930 "context = %d, mode = %s, first = %d, count = %d, primcount = %d", CID(context),
931 GLenumToString(GLESEnum::PrimitiveType, mode), first, count, primcount);
932
933 if (context)
934 {
935 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
936 SCOPED_SHARE_CONTEXT_LOCK(context);
937 bool isCallValid = (context->skipValidation() ||
938 ValidateDrawArraysInstancedANGLE(
939 context, angle::EntryPoint::GLDrawArraysInstancedANGLE, modePacked,
940 first, count, primcount));
941 if (isCallValid)
942 {
943 context->drawArraysInstanced(modePacked, first, count, primcount);
944 }
945 ANGLE_CAPTURE_GL(DrawArraysInstancedANGLE, isCallValid, context, modePacked, first, count,
946 primcount);
947 }
948 else
949 {
950 GenerateContextLostErrorOnCurrentGlobalContext();
951 }
952 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
953 }
954
GL_DrawElementsInstancedANGLE(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei primcount)955 void GL_APIENTRY GL_DrawElementsInstancedANGLE(GLenum mode,
956 GLsizei count,
957 GLenum type,
958 const void *indices,
959 GLsizei primcount)
960 {
961 Context *context = GetValidGlobalContext();
962 EVENT(context, GLDrawElementsInstancedANGLE,
963 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
964 ", primcount = %d",
965 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count,
966 GLenumToString(GLESEnum::PrimitiveType, type), (uintptr_t)indices, primcount);
967
968 if (context)
969 {
970 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
971 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
972 SCOPED_SHARE_CONTEXT_LOCK(context);
973 bool isCallValid = (context->skipValidation() ||
974 ValidateDrawElementsInstancedANGLE(
975 context, angle::EntryPoint::GLDrawElementsInstancedANGLE,
976 modePacked, count, typePacked, indices, primcount));
977 if (isCallValid)
978 {
979 context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
980 }
981 ANGLE_CAPTURE_GL(DrawElementsInstancedANGLE, isCallValid, context, modePacked, count,
982 typePacked, indices, primcount);
983 }
984 else
985 {
986 GenerateContextLostErrorOnCurrentGlobalContext();
987 }
988 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
989 }
990
GL_VertexAttribDivisorANGLE(GLuint index,GLuint divisor)991 void GL_APIENTRY GL_VertexAttribDivisorANGLE(GLuint index, GLuint divisor)
992 {
993 Context *context = GetValidGlobalContext();
994 EVENT(context, GLVertexAttribDivisorANGLE, "context = %d, index = %u, divisor = %u",
995 CID(context), index, divisor);
996
997 if (context)
998 {
999 SCOPED_SHARE_CONTEXT_LOCK(context);
1000 bool isCallValid =
1001 (context->skipValidation() ||
1002 ValidateVertexAttribDivisorANGLE(
1003 context, angle::EntryPoint::GLVertexAttribDivisorANGLE, index, divisor));
1004 if (isCallValid)
1005 {
1006 context->vertexAttribDivisor(index, divisor);
1007 }
1008 ANGLE_CAPTURE_GL(VertexAttribDivisorANGLE, isCallValid, context, index, divisor);
1009 }
1010 else
1011 {
1012 GenerateContextLostErrorOnCurrentGlobalContext();
1013 }
1014 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1015 }
1016
1017 // GL_ANGLE_logic_op
GL_LogicOpANGLE(GLenum opcode)1018 void GL_APIENTRY GL_LogicOpANGLE(GLenum opcode)
1019 {
1020 Context *context = GetValidGlobalContext();
1021 EVENT(context, GLLogicOpANGLE, "context = %d, opcode = %s", CID(context),
1022 GLenumToString(GLESEnum::LogicOp, opcode));
1023
1024 if (context)
1025 {
1026 LogicalOperation opcodePacked = PackParam<LogicalOperation>(opcode);
1027 bool isCallValid =
1028 (context->skipValidation() ||
1029 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1030 context->getMutableErrorSetForValidation(),
1031 angle::EntryPoint::GLLogicOpANGLE) &&
1032 ValidateLogicOpANGLE(context->getPrivateState(),
1033 context->getMutableErrorSetForValidation(),
1034 angle::EntryPoint::GLLogicOpANGLE, opcodePacked)));
1035 if (isCallValid)
1036 {
1037 ContextPrivateLogicOpANGLE(context->getMutablePrivateState(),
1038 context->getMutablePrivateStateCache(), opcodePacked);
1039 }
1040 ANGLE_CAPTURE_GL(LogicOpANGLE, isCallValid, context, opcodePacked);
1041 }
1042 else
1043 {
1044 GenerateContextLostErrorOnCurrentGlobalContext();
1045 }
1046 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1047 }
1048
1049 // GL_ANGLE_lossy_etc_decode
1050
1051 // 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)1052 void GL_APIENTRY GL_TexStorageMemFlags2DANGLE(GLenum target,
1053 GLsizei levels,
1054 GLenum internalFormat,
1055 GLsizei width,
1056 GLsizei height,
1057 GLuint memory,
1058 GLuint64 offset,
1059 GLbitfield createFlags,
1060 GLbitfield usageFlags,
1061 const void *imageCreateInfoPNext)
1062 {
1063 Context *context = GetValidGlobalContext();
1064 EVENT(context, GLTexStorageMemFlags2DANGLE,
1065 "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, "
1066 "memory = %u, offset = %llu, createFlags = %s, usageFlags = %s, imageCreateInfoPNext = "
1067 "0x%016" PRIxPTR "",
1068 CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels,
1069 GLenumToString(GLESEnum::AllEnums, internalFormat), width, height, memory,
1070 static_cast<unsigned long long>(offset),
1071 GLbitfieldToString(GLESEnum::AllEnums, createFlags).c_str(),
1072 GLbitfieldToString(GLESEnum::AllEnums, usageFlags).c_str(),
1073 (uintptr_t)imageCreateInfoPNext);
1074
1075 if (context)
1076 {
1077 TextureType targetPacked = PackParam<TextureType>(target);
1078 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
1079 SCOPED_SHARE_CONTEXT_LOCK(context);
1080 bool isCallValid =
1081 (context->skipValidation() ||
1082 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1083 context->getMutableErrorSetForValidation(),
1084 angle::EntryPoint::GLTexStorageMemFlags2DANGLE) &&
1085 ValidateTexStorageMemFlags2DANGLE(
1086 context, angle::EntryPoint::GLTexStorageMemFlags2DANGLE, targetPacked, levels,
1087 internalFormat, width, height, memoryPacked, offset, createFlags, usageFlags,
1088 imageCreateInfoPNext)));
1089 if (isCallValid)
1090 {
1091 context->texStorageMemFlags2D(targetPacked, levels, internalFormat, width, height,
1092 memoryPacked, offset, createFlags, usageFlags,
1093 imageCreateInfoPNext);
1094 }
1095 ANGLE_CAPTURE_GL(TexStorageMemFlags2DANGLE, isCallValid, context, targetPacked, levels,
1096 internalFormat, width, height, memoryPacked, offset, createFlags,
1097 usageFlags, imageCreateInfoPNext);
1098 }
1099 else
1100 {
1101 GenerateContextLostErrorOnCurrentGlobalContext();
1102 }
1103 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1104 }
1105
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)1106 void GL_APIENTRY GL_TexStorageMemFlags2DMultisampleANGLE(GLenum target,
1107 GLsizei samples,
1108 GLenum internalFormat,
1109 GLsizei width,
1110 GLsizei height,
1111 GLboolean fixedSampleLocations,
1112 GLuint memory,
1113 GLuint64 offset,
1114 GLbitfield createFlags,
1115 GLbitfield usageFlags,
1116 const void *imageCreateInfoPNext)
1117 {
1118 Context *context = GetValidGlobalContext();
1119 EVENT(context, GLTexStorageMemFlags2DMultisampleANGLE,
1120 "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, "
1121 "fixedSampleLocations = %s, memory = %u, offset = %llu, createFlags = %s, usageFlags = "
1122 "%s, imageCreateInfoPNext = 0x%016" PRIxPTR "",
1123 CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples,
1124 GLenumToString(GLESEnum::AllEnums, internalFormat), width, height,
1125 GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset),
1126 GLbitfieldToString(GLESEnum::AllEnums, createFlags).c_str(),
1127 GLbitfieldToString(GLESEnum::AllEnums, usageFlags).c_str(),
1128 (uintptr_t)imageCreateInfoPNext);
1129
1130 if (context)
1131 {
1132 TextureType targetPacked = PackParam<TextureType>(target);
1133 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
1134 SCOPED_SHARE_CONTEXT_LOCK(context);
1135 bool isCallValid =
1136 (context->skipValidation() ||
1137 (ValidatePixelLocalStorageInactive(
1138 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1139 angle::EntryPoint::GLTexStorageMemFlags2DMultisampleANGLE) &&
1140 ValidateTexStorageMemFlags2DMultisampleANGLE(
1141 context, angle::EntryPoint::GLTexStorageMemFlags2DMultisampleANGLE, targetPacked,
1142 samples, internalFormat, width, height, fixedSampleLocations, memoryPacked,
1143 offset, createFlags, usageFlags, imageCreateInfoPNext)));
1144 if (isCallValid)
1145 {
1146 context->texStorageMemFlags2DMultisample(
1147 targetPacked, samples, internalFormat, width, height, fixedSampleLocations,
1148 memoryPacked, offset, createFlags, usageFlags, imageCreateInfoPNext);
1149 }
1150 ANGLE_CAPTURE_GL(TexStorageMemFlags2DMultisampleANGLE, isCallValid, context, targetPacked,
1151 samples, internalFormat, width, height, fixedSampleLocations, memoryPacked,
1152 offset, createFlags, usageFlags, imageCreateInfoPNext);
1153 }
1154 else
1155 {
1156 GenerateContextLostErrorOnCurrentGlobalContext();
1157 }
1158 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1159 }
1160
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)1161 void GL_APIENTRY GL_TexStorageMemFlags3DANGLE(GLenum target,
1162 GLsizei levels,
1163 GLenum internalFormat,
1164 GLsizei width,
1165 GLsizei height,
1166 GLsizei depth,
1167 GLuint memory,
1168 GLuint64 offset,
1169 GLbitfield createFlags,
1170 GLbitfield usageFlags,
1171 const void *imageCreateInfoPNext)
1172 {
1173 Context *context = GetValidGlobalContext();
1174 EVENT(context, GLTexStorageMemFlags3DANGLE,
1175 "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, "
1176 "depth = %d, memory = %u, offset = %llu, createFlags = %s, usageFlags = %s, "
1177 "imageCreateInfoPNext = 0x%016" PRIxPTR "",
1178 CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels,
1179 GLenumToString(GLESEnum::AllEnums, internalFormat), width, height, depth, memory,
1180 static_cast<unsigned long long>(offset),
1181 GLbitfieldToString(GLESEnum::AllEnums, createFlags).c_str(),
1182 GLbitfieldToString(GLESEnum::AllEnums, usageFlags).c_str(),
1183 (uintptr_t)imageCreateInfoPNext);
1184
1185 if (context)
1186 {
1187 TextureType targetPacked = PackParam<TextureType>(target);
1188 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
1189 SCOPED_SHARE_CONTEXT_LOCK(context);
1190 bool isCallValid =
1191 (context->skipValidation() ||
1192 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1193 context->getMutableErrorSetForValidation(),
1194 angle::EntryPoint::GLTexStorageMemFlags3DANGLE) &&
1195 ValidateTexStorageMemFlags3DANGLE(
1196 context, angle::EntryPoint::GLTexStorageMemFlags3DANGLE, targetPacked, levels,
1197 internalFormat, width, height, depth, memoryPacked, offset, createFlags,
1198 usageFlags, imageCreateInfoPNext)));
1199 if (isCallValid)
1200 {
1201 context->texStorageMemFlags3D(targetPacked, levels, internalFormat, width, height,
1202 depth, memoryPacked, offset, createFlags, usageFlags,
1203 imageCreateInfoPNext);
1204 }
1205 ANGLE_CAPTURE_GL(TexStorageMemFlags3DANGLE, isCallValid, context, targetPacked, levels,
1206 internalFormat, width, height, depth, memoryPacked, offset, createFlags,
1207 usageFlags, imageCreateInfoPNext);
1208 }
1209 else
1210 {
1211 GenerateContextLostErrorOnCurrentGlobalContext();
1212 }
1213 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1214 }
1215
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)1216 void GL_APIENTRY GL_TexStorageMemFlags3DMultisampleANGLE(GLenum target,
1217 GLsizei samples,
1218 GLenum internalFormat,
1219 GLsizei width,
1220 GLsizei height,
1221 GLsizei depth,
1222 GLboolean fixedSampleLocations,
1223 GLuint memory,
1224 GLuint64 offset,
1225 GLbitfield createFlags,
1226 GLbitfield usageFlags,
1227 const void *imageCreateInfoPNext)
1228 {
1229 Context *context = GetValidGlobalContext();
1230 EVENT(context, GLTexStorageMemFlags3DMultisampleANGLE,
1231 "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, "
1232 "depth = %d, fixedSampleLocations = %s, memory = %u, offset = %llu, createFlags = %s, "
1233 "usageFlags = %s, imageCreateInfoPNext = 0x%016" PRIxPTR "",
1234 CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples,
1235 GLenumToString(GLESEnum::AllEnums, internalFormat), width, height, depth,
1236 GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset),
1237 GLbitfieldToString(GLESEnum::AllEnums, createFlags).c_str(),
1238 GLbitfieldToString(GLESEnum::AllEnums, usageFlags).c_str(),
1239 (uintptr_t)imageCreateInfoPNext);
1240
1241 if (context)
1242 {
1243 TextureType targetPacked = PackParam<TextureType>(target);
1244 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
1245 SCOPED_SHARE_CONTEXT_LOCK(context);
1246 bool isCallValid =
1247 (context->skipValidation() ||
1248 (ValidatePixelLocalStorageInactive(
1249 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1250 angle::EntryPoint::GLTexStorageMemFlags3DMultisampleANGLE) &&
1251 ValidateTexStorageMemFlags3DMultisampleANGLE(
1252 context, angle::EntryPoint::GLTexStorageMemFlags3DMultisampleANGLE, targetPacked,
1253 samples, internalFormat, width, height, depth, fixedSampleLocations, memoryPacked,
1254 offset, createFlags, usageFlags, imageCreateInfoPNext)));
1255 if (isCallValid)
1256 {
1257 context->texStorageMemFlags3DMultisample(
1258 targetPacked, samples, internalFormat, width, height, depth, fixedSampleLocations,
1259 memoryPacked, offset, createFlags, usageFlags, imageCreateInfoPNext);
1260 }
1261 ANGLE_CAPTURE_GL(TexStorageMemFlags3DMultisampleANGLE, isCallValid, context, targetPacked,
1262 samples, internalFormat, width, height, depth, fixedSampleLocations,
1263 memoryPacked, offset, createFlags, usageFlags, imageCreateInfoPNext);
1264 }
1265 else
1266 {
1267 GenerateContextLostErrorOnCurrentGlobalContext();
1268 }
1269 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1270 }
1271
1272 // GL_ANGLE_memory_object_fuchsia
GL_ImportMemoryZirconHandleANGLE(GLuint memory,GLuint64 size,GLenum handleType,GLuint handle)1273 void GL_APIENTRY GL_ImportMemoryZirconHandleANGLE(GLuint memory,
1274 GLuint64 size,
1275 GLenum handleType,
1276 GLuint handle)
1277 {
1278 Context *context = GetValidGlobalContext();
1279 EVENT(context, GLImportMemoryZirconHandleANGLE,
1280 "context = %d, memory = %u, size = %llu, handleType = %s, handle = %u", CID(context),
1281 memory, static_cast<unsigned long long>(size),
1282 GLenumToString(GLESEnum::ExternalHandleType, handleType), handle);
1283
1284 if (context)
1285 {
1286 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
1287 HandleType handleTypePacked = PackParam<HandleType>(handleType);
1288 SCOPED_SHARE_CONTEXT_LOCK(context);
1289 bool isCallValid =
1290 (context->skipValidation() ||
1291 (ValidatePixelLocalStorageInactive(
1292 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1293 angle::EntryPoint::GLImportMemoryZirconHandleANGLE) &&
1294 ValidateImportMemoryZirconHandleANGLE(
1295 context, angle::EntryPoint::GLImportMemoryZirconHandleANGLE, memoryPacked, size,
1296 handleTypePacked, handle)));
1297 if (isCallValid)
1298 {
1299 context->importMemoryZirconHandle(memoryPacked, size, handleTypePacked, handle);
1300 }
1301 ANGLE_CAPTURE_GL(ImportMemoryZirconHandleANGLE, isCallValid, context, memoryPacked, size,
1302 handleTypePacked, handle);
1303 }
1304 else
1305 {
1306 GenerateContextLostErrorOnCurrentGlobalContext();
1307 }
1308 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1309 }
1310
1311 // GL_ANGLE_memory_size
1312
1313 // GL_ANGLE_multi_draw
GL_MultiDrawArraysANGLE(GLenum mode,const GLint * firsts,const GLsizei * counts,GLsizei drawcount)1314 void GL_APIENTRY GL_MultiDrawArraysANGLE(GLenum mode,
1315 const GLint *firsts,
1316 const GLsizei *counts,
1317 GLsizei drawcount)
1318 {
1319 Context *context = GetValidGlobalContext();
1320 EVENT(context, GLMultiDrawArraysANGLE,
1321 "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR
1322 ", drawcount = %d",
1323 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)firsts,
1324 (uintptr_t)counts, drawcount);
1325
1326 if (context)
1327 {
1328 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
1329 SCOPED_SHARE_CONTEXT_LOCK(context);
1330 bool isCallValid =
1331 (context->skipValidation() ||
1332 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1333 context->getMutableErrorSetForValidation(),
1334 angle::EntryPoint::GLMultiDrawArraysANGLE) &&
1335 ValidateMultiDrawArraysANGLE(context, angle::EntryPoint::GLMultiDrawArraysANGLE,
1336 modePacked, firsts, counts, drawcount)));
1337 if (isCallValid)
1338 {
1339 context->multiDrawArrays(modePacked, firsts, counts, drawcount);
1340 }
1341 ANGLE_CAPTURE_GL(MultiDrawArraysANGLE, isCallValid, context, modePacked, firsts, counts,
1342 drawcount);
1343 }
1344 else
1345 {
1346 GenerateContextLostErrorOnCurrentGlobalContext();
1347 }
1348 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1349 }
1350
GL_MultiDrawArraysInstancedANGLE(GLenum mode,const GLint * firsts,const GLsizei * counts,const GLsizei * instanceCounts,GLsizei drawcount)1351 void GL_APIENTRY GL_MultiDrawArraysInstancedANGLE(GLenum mode,
1352 const GLint *firsts,
1353 const GLsizei *counts,
1354 const GLsizei *instanceCounts,
1355 GLsizei drawcount)
1356 {
1357 Context *context = GetValidGlobalContext();
1358 EVENT(context, GLMultiDrawArraysInstancedANGLE,
1359 "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR
1360 ", instanceCounts = 0x%016" PRIxPTR ", drawcount = %d",
1361 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)firsts,
1362 (uintptr_t)counts, (uintptr_t)instanceCounts, drawcount);
1363
1364 if (context)
1365 {
1366 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
1367 SCOPED_SHARE_CONTEXT_LOCK(context);
1368 bool isCallValid =
1369 (context->skipValidation() ||
1370 (ValidatePixelLocalStorageInactive(
1371 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1372 angle::EntryPoint::GLMultiDrawArraysInstancedANGLE) &&
1373 ValidateMultiDrawArraysInstancedANGLE(
1374 context, angle::EntryPoint::GLMultiDrawArraysInstancedANGLE, modePacked, firsts,
1375 counts, instanceCounts, drawcount)));
1376 if (isCallValid)
1377 {
1378 context->multiDrawArraysInstanced(modePacked, firsts, counts, instanceCounts,
1379 drawcount);
1380 }
1381 ANGLE_CAPTURE_GL(MultiDrawArraysInstancedANGLE, isCallValid, context, modePacked, firsts,
1382 counts, instanceCounts, drawcount);
1383 }
1384 else
1385 {
1386 GenerateContextLostErrorOnCurrentGlobalContext();
1387 }
1388 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1389 }
1390
GL_MultiDrawElementsANGLE(GLenum mode,const GLsizei * counts,GLenum type,const void * const * indices,GLsizei drawcount)1391 void GL_APIENTRY GL_MultiDrawElementsANGLE(GLenum mode,
1392 const GLsizei *counts,
1393 GLenum type,
1394 const void *const *indices,
1395 GLsizei drawcount)
1396 {
1397 Context *context = GetValidGlobalContext();
1398 EVENT(context, GLMultiDrawElementsANGLE,
1399 "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
1400 ", drawcount = %d",
1401 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)counts,
1402 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, drawcount);
1403
1404 if (context)
1405 {
1406 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
1407 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
1408 SCOPED_SHARE_CONTEXT_LOCK(context);
1409 bool isCallValid =
1410 (context->skipValidation() ||
1411 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1412 context->getMutableErrorSetForValidation(),
1413 angle::EntryPoint::GLMultiDrawElementsANGLE) &&
1414 ValidateMultiDrawElementsANGLE(context, angle::EntryPoint::GLMultiDrawElementsANGLE,
1415 modePacked, counts, typePacked, indices, drawcount)));
1416 if (isCallValid)
1417 {
1418 context->multiDrawElements(modePacked, counts, typePacked, indices, drawcount);
1419 }
1420 ANGLE_CAPTURE_GL(MultiDrawElementsANGLE, isCallValid, context, modePacked, counts,
1421 typePacked, indices, drawcount);
1422 }
1423 else
1424 {
1425 GenerateContextLostErrorOnCurrentGlobalContext();
1426 }
1427 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1428 }
1429
GL_MultiDrawElementsInstancedANGLE(GLenum mode,const GLsizei * counts,GLenum type,const void * const * indices,const GLsizei * instanceCounts,GLsizei drawcount)1430 void GL_APIENTRY GL_MultiDrawElementsInstancedANGLE(GLenum mode,
1431 const GLsizei *counts,
1432 GLenum type,
1433 const void *const *indices,
1434 const GLsizei *instanceCounts,
1435 GLsizei drawcount)
1436 {
1437 Context *context = GetValidGlobalContext();
1438 EVENT(context, GLMultiDrawElementsInstancedANGLE,
1439 "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
1440 ", instanceCounts = 0x%016" PRIxPTR ", drawcount = %d",
1441 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)counts,
1442 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices,
1443 (uintptr_t)instanceCounts, drawcount);
1444
1445 if (context)
1446 {
1447 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
1448 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
1449 SCOPED_SHARE_CONTEXT_LOCK(context);
1450 bool isCallValid =
1451 (context->skipValidation() ||
1452 (ValidatePixelLocalStorageInactive(
1453 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1454 angle::EntryPoint::GLMultiDrawElementsInstancedANGLE) &&
1455 ValidateMultiDrawElementsInstancedANGLE(
1456 context, angle::EntryPoint::GLMultiDrawElementsInstancedANGLE, modePacked, counts,
1457 typePacked, indices, instanceCounts, drawcount)));
1458 if (isCallValid)
1459 {
1460 context->multiDrawElementsInstanced(modePacked, counts, typePacked, indices,
1461 instanceCounts, drawcount);
1462 }
1463 ANGLE_CAPTURE_GL(MultiDrawElementsInstancedANGLE, isCallValid, context, modePacked, counts,
1464 typePacked, indices, instanceCounts, drawcount);
1465 }
1466 else
1467 {
1468 GenerateContextLostErrorOnCurrentGlobalContext();
1469 }
1470 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1471 }
1472
1473 // GL_ANGLE_pack_reverse_row_order
1474
1475 // GL_ANGLE_polygon_mode
GL_PolygonModeANGLE(GLenum face,GLenum mode)1476 void GL_APIENTRY GL_PolygonModeANGLE(GLenum face, GLenum mode)
1477 {
1478 Context *context = GetValidGlobalContext();
1479 EVENT(context, GLPolygonModeANGLE, "context = %d, face = %s, mode = %s", CID(context),
1480 GLenumToString(GLESEnum::TriangleFace, face),
1481 GLenumToString(GLESEnum::PolygonMode, mode));
1482
1483 if (context)
1484 {
1485 PolygonMode modePacked = PackParam<PolygonMode>(mode);
1486 bool isCallValid =
1487 (context->skipValidation() ||
1488 ValidatePolygonModeANGLE(context->getPrivateState(),
1489 context->getMutableErrorSetForValidation(),
1490 angle::EntryPoint::GLPolygonModeANGLE, face, modePacked));
1491 if (isCallValid)
1492 {
1493 ContextPrivatePolygonMode(context->getMutablePrivateState(),
1494 context->getMutablePrivateStateCache(), face, modePacked);
1495 }
1496 ANGLE_CAPTURE_GL(PolygonModeANGLE, isCallValid, context, face, modePacked);
1497 }
1498 else
1499 {
1500 GenerateContextLostErrorOnCurrentGlobalContext();
1501 }
1502 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1503 }
1504
1505 // GL_ANGLE_program_binary
1506
1507 // GL_ANGLE_program_binary_readiness_query
1508
1509 // GL_ANGLE_program_cache_control
1510
1511 // GL_ANGLE_provoking_vertex
GL_ProvokingVertexANGLE(GLenum provokeMode)1512 void GL_APIENTRY GL_ProvokingVertexANGLE(GLenum provokeMode)
1513 {
1514 Context *context = GetValidGlobalContext();
1515 EVENT(context, GLProvokingVertexANGLE, "context = %d, provokeMode = %s", CID(context),
1516 GLenumToString(GLESEnum::VertexProvokingMode, provokeMode));
1517
1518 if (context)
1519 {
1520 ProvokingVertexConvention provokeModePacked =
1521 PackParam<ProvokingVertexConvention>(provokeMode);
1522 bool isCallValid =
1523 (context->skipValidation() ||
1524 ValidateProvokingVertexANGLE(
1525 context->getPrivateState(), context->getMutableErrorSetForValidation(),
1526 angle::EntryPoint::GLProvokingVertexANGLE, provokeModePacked));
1527 if (isCallValid)
1528 {
1529 ContextPrivateProvokingVertex(context->getMutablePrivateState(),
1530 context->getMutablePrivateStateCache(),
1531 provokeModePacked);
1532 }
1533 ANGLE_CAPTURE_GL(ProvokingVertexANGLE, isCallValid, context, provokeModePacked);
1534 }
1535 else
1536 {
1537 GenerateContextLostErrorOnCurrentGlobalContext();
1538 }
1539 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1540 }
1541
1542 // GL_ANGLE_renderability_validation
1543
1544 // GL_ANGLE_request_extension
GL_RequestExtensionANGLE(const GLchar * name)1545 void GL_APIENTRY GL_RequestExtensionANGLE(const GLchar *name)
1546 {
1547 Context *context = GetValidGlobalContext();
1548 EVENT(context, GLRequestExtensionANGLE, "context = %d, name = 0x%016" PRIxPTR "", CID(context),
1549 (uintptr_t)name);
1550
1551 if (context)
1552 {
1553 SCOPED_SHARE_CONTEXT_LOCK(context);
1554 bool isCallValid =
1555 (context->skipValidation() ||
1556 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1557 context->getMutableErrorSetForValidation(),
1558 angle::EntryPoint::GLRequestExtensionANGLE) &&
1559 ValidateRequestExtensionANGLE(context, angle::EntryPoint::GLRequestExtensionANGLE,
1560 name)));
1561 if (isCallValid)
1562 {
1563 context->requestExtension(name);
1564 }
1565 ANGLE_CAPTURE_GL(RequestExtensionANGLE, isCallValid, context, name);
1566 }
1567 else
1568 {
1569 GenerateContextLostErrorOnCurrentGlobalContext();
1570 }
1571 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1572 }
1573
GL_DisableExtensionANGLE(const GLchar * name)1574 void GL_APIENTRY GL_DisableExtensionANGLE(const GLchar *name)
1575 {
1576 Context *context = GetValidGlobalContext();
1577 EVENT(context, GLDisableExtensionANGLE, "context = %d, name = 0x%016" PRIxPTR "", CID(context),
1578 (uintptr_t)name);
1579
1580 if (context)
1581 {
1582 SCOPED_SHARE_CONTEXT_LOCK(context);
1583 bool isCallValid =
1584 (context->skipValidation() ||
1585 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
1586 context->getMutableErrorSetForValidation(),
1587 angle::EntryPoint::GLDisableExtensionANGLE) &&
1588 ValidateDisableExtensionANGLE(context, angle::EntryPoint::GLDisableExtensionANGLE,
1589 name)));
1590 if (isCallValid)
1591 {
1592 context->disableExtension(name);
1593 }
1594 ANGLE_CAPTURE_GL(DisableExtensionANGLE, isCallValid, context, name);
1595 }
1596 else
1597 {
1598 GenerateContextLostErrorOnCurrentGlobalContext();
1599 }
1600 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1601 }
1602
1603 // GL_ANGLE_rgbx_internal_format
1604
1605 // GL_ANGLE_robust_client_memory
GL_GetBooleanvRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLboolean * params)1606 void GL_APIENTRY GL_GetBooleanvRobustANGLE(GLenum pname,
1607 GLsizei bufSize,
1608 GLsizei *length,
1609 GLboolean *params)
1610 {
1611 Context *context = GetValidGlobalContext();
1612 EVENT(context, GLGetBooleanvRobustANGLE,
1613 "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1614 ", params = 0x%016" PRIxPTR "",
1615 CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length,
1616 (uintptr_t)params);
1617
1618 if (context)
1619 {
1620 SCOPED_SHARE_CONTEXT_LOCK(context);
1621 bool isCallValid =
1622 (context->skipValidation() ||
1623 ValidateGetBooleanvRobustANGLE(context, angle::EntryPoint::GLGetBooleanvRobustANGLE,
1624 pname, bufSize, length, params));
1625 if (isCallValid)
1626 {
1627 context->getBooleanvRobust(pname, bufSize, length, params);
1628 }
1629 ANGLE_CAPTURE_GL(GetBooleanvRobustANGLE, isCallValid, context, pname, bufSize, length,
1630 params);
1631 }
1632 else
1633 {
1634 GenerateContextLostErrorOnCurrentGlobalContext();
1635 }
1636 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1637 }
1638
GL_GetBufferParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1639 void GL_APIENTRY GL_GetBufferParameterivRobustANGLE(GLenum target,
1640 GLenum pname,
1641 GLsizei bufSize,
1642 GLsizei *length,
1643 GLint *params)
1644 {
1645 Context *context = GetValidGlobalContext();
1646 EVENT(context, GLGetBufferParameterivRobustANGLE,
1647 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1648 ", params = 0x%016" PRIxPTR "",
1649 CID(context), GLenumToString(GLESEnum::AllEnums, target),
1650 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
1651
1652 if (context)
1653 {
1654 BufferBinding targetPacked = PackParam<BufferBinding>(target);
1655 SCOPED_SHARE_CONTEXT_LOCK(context);
1656 bool isCallValid = (context->skipValidation() ||
1657 ValidateGetBufferParameterivRobustANGLE(
1658 context, angle::EntryPoint::GLGetBufferParameterivRobustANGLE,
1659 targetPacked, pname, bufSize, length, params));
1660 if (isCallValid)
1661 {
1662 context->getBufferParameterivRobust(targetPacked, pname, bufSize, length, params);
1663 }
1664 ANGLE_CAPTURE_GL(GetBufferParameterivRobustANGLE, isCallValid, context, targetPacked, pname,
1665 bufSize, length, params);
1666 }
1667 else
1668 {
1669 GenerateContextLostErrorOnCurrentGlobalContext();
1670 }
1671 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1672 }
1673
GL_GetFloatvRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1674 void GL_APIENTRY GL_GetFloatvRobustANGLE(GLenum pname,
1675 GLsizei bufSize,
1676 GLsizei *length,
1677 GLfloat *params)
1678 {
1679 Context *context = GetValidGlobalContext();
1680 EVENT(context, GLGetFloatvRobustANGLE,
1681 "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1682 ", params = 0x%016" PRIxPTR "",
1683 CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length,
1684 (uintptr_t)params);
1685
1686 if (context)
1687 {
1688 SCOPED_SHARE_CONTEXT_LOCK(context);
1689 bool isCallValid =
1690 (context->skipValidation() ||
1691 ValidateGetFloatvRobustANGLE(context, angle::EntryPoint::GLGetFloatvRobustANGLE, pname,
1692 bufSize, length, params));
1693 if (isCallValid)
1694 {
1695 context->getFloatvRobust(pname, bufSize, length, params);
1696 }
1697 ANGLE_CAPTURE_GL(GetFloatvRobustANGLE, isCallValid, context, pname, bufSize, length,
1698 params);
1699 }
1700 else
1701 {
1702 GenerateContextLostErrorOnCurrentGlobalContext();
1703 }
1704 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1705 }
1706
GL_GetFramebufferAttachmentParameterivRobustANGLE(GLenum target,GLenum attachment,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1707 void GL_APIENTRY GL_GetFramebufferAttachmentParameterivRobustANGLE(GLenum target,
1708 GLenum attachment,
1709 GLenum pname,
1710 GLsizei bufSize,
1711 GLsizei *length,
1712 GLint *params)
1713 {
1714 Context *context = GetValidGlobalContext();
1715 EVENT(context, GLGetFramebufferAttachmentParameterivRobustANGLE,
1716 "context = %d, target = %s, attachment = %s, pname = %s, bufSize = %d, length = "
1717 "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
1718 CID(context), GLenumToString(GLESEnum::AllEnums, target),
1719 GLenumToString(GLESEnum::AllEnums, attachment), GLenumToString(GLESEnum::AllEnums, pname),
1720 bufSize, (uintptr_t)length, (uintptr_t)params);
1721
1722 if (context)
1723 {
1724 SCOPED_SHARE_CONTEXT_LOCK(context);
1725 bool isCallValid =
1726 (context->skipValidation() ||
1727 ValidateGetFramebufferAttachmentParameterivRobustANGLE(
1728 context, angle::EntryPoint::GLGetFramebufferAttachmentParameterivRobustANGLE,
1729 target, attachment, pname, bufSize, length, params));
1730 if (isCallValid)
1731 {
1732 context->getFramebufferAttachmentParameterivRobust(target, attachment, pname, bufSize,
1733 length, params);
1734 }
1735 ANGLE_CAPTURE_GL(GetFramebufferAttachmentParameterivRobustANGLE, isCallValid, context,
1736 target, attachment, pname, bufSize, length, params);
1737 }
1738 else
1739 {
1740 GenerateContextLostErrorOnCurrentGlobalContext();
1741 }
1742 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1743 }
1744
GL_GetIntegervRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLint * data)1745 void GL_APIENTRY GL_GetIntegervRobustANGLE(GLenum pname,
1746 GLsizei bufSize,
1747 GLsizei *length,
1748 GLint *data)
1749 {
1750 Context *context = GetValidGlobalContext();
1751 EVENT(context, GLGetIntegervRobustANGLE,
1752 "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1753 ", data = 0x%016" PRIxPTR "",
1754 CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length,
1755 (uintptr_t)data);
1756
1757 if (context)
1758 {
1759 SCOPED_SHARE_CONTEXT_LOCK(context);
1760 bool isCallValid =
1761 (context->skipValidation() ||
1762 ValidateGetIntegervRobustANGLE(context, angle::EntryPoint::GLGetIntegervRobustANGLE,
1763 pname, bufSize, length, data));
1764 if (isCallValid)
1765 {
1766 context->getIntegervRobust(pname, bufSize, length, data);
1767 }
1768 ANGLE_CAPTURE_GL(GetIntegervRobustANGLE, isCallValid, context, pname, bufSize, length,
1769 data);
1770 }
1771 else
1772 {
1773 GenerateContextLostErrorOnCurrentGlobalContext();
1774 }
1775 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1776 }
1777
GL_GetProgramivRobustANGLE(GLuint program,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1778 void GL_APIENTRY GL_GetProgramivRobustANGLE(GLuint program,
1779 GLenum pname,
1780 GLsizei bufSize,
1781 GLsizei *length,
1782 GLint *params)
1783 {
1784 Context *context = GetGlobalContext();
1785 EVENT(context, GLGetProgramivRobustANGLE,
1786 "context = %d, program = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1787 ", params = 0x%016" PRIxPTR "",
1788 CID(context), program, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
1789 (uintptr_t)length, (uintptr_t)params);
1790
1791 if (context)
1792 {
1793 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1794 SCOPED_SHARE_CONTEXT_LOCK(context);
1795 bool isCallValid =
1796 (context->skipValidation() ||
1797 ValidateGetProgramivRobustANGLE(context, angle::EntryPoint::GLGetProgramivRobustANGLE,
1798 programPacked, pname, bufSize, length, params));
1799 if (isCallValid)
1800 {
1801 context->getProgramivRobust(programPacked, pname, bufSize, length, params);
1802 }
1803 ANGLE_CAPTURE_GL(GetProgramivRobustANGLE, isCallValid, context, programPacked, pname,
1804 bufSize, length, params);
1805 }
1806 else
1807 {
1808 }
1809 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1810 }
1811
GL_GetRenderbufferParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1812 void GL_APIENTRY GL_GetRenderbufferParameterivRobustANGLE(GLenum target,
1813 GLenum pname,
1814 GLsizei bufSize,
1815 GLsizei *length,
1816 GLint *params)
1817 {
1818 Context *context = GetValidGlobalContext();
1819 EVENT(context, GLGetRenderbufferParameterivRobustANGLE,
1820 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1821 ", params = 0x%016" PRIxPTR "",
1822 CID(context), GLenumToString(GLESEnum::AllEnums, target),
1823 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
1824
1825 if (context)
1826 {
1827 SCOPED_SHARE_CONTEXT_LOCK(context);
1828 bool isCallValid = (context->skipValidation() ||
1829 ValidateGetRenderbufferParameterivRobustANGLE(
1830 context, angle::EntryPoint::GLGetRenderbufferParameterivRobustANGLE,
1831 target, pname, bufSize, length, params));
1832 if (isCallValid)
1833 {
1834 context->getRenderbufferParameterivRobust(target, pname, bufSize, length, params);
1835 }
1836 ANGLE_CAPTURE_GL(GetRenderbufferParameterivRobustANGLE, isCallValid, context, target, pname,
1837 bufSize, length, params);
1838 }
1839 else
1840 {
1841 GenerateContextLostErrorOnCurrentGlobalContext();
1842 }
1843 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1844 }
1845
GL_GetShaderivRobustANGLE(GLuint shader,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1846 void GL_APIENTRY GL_GetShaderivRobustANGLE(GLuint shader,
1847 GLenum pname,
1848 GLsizei bufSize,
1849 GLsizei *length,
1850 GLint *params)
1851 {
1852 Context *context = GetGlobalContext();
1853 EVENT(context, GLGetShaderivRobustANGLE,
1854 "context = %d, shader = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1855 ", params = 0x%016" PRIxPTR "",
1856 CID(context), shader, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
1857 (uintptr_t)length, (uintptr_t)params);
1858
1859 if (context)
1860 {
1861 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
1862 SCOPED_SHARE_CONTEXT_LOCK(context);
1863 bool isCallValid =
1864 (context->skipValidation() ||
1865 ValidateGetShaderivRobustANGLE(context, angle::EntryPoint::GLGetShaderivRobustANGLE,
1866 shaderPacked, pname, bufSize, length, params));
1867 if (isCallValid)
1868 {
1869 context->getShaderivRobust(shaderPacked, pname, bufSize, length, params);
1870 }
1871 ANGLE_CAPTURE_GL(GetShaderivRobustANGLE, isCallValid, context, shaderPacked, pname, bufSize,
1872 length, params);
1873 }
1874 else
1875 {
1876 }
1877 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1878 }
1879
GL_GetTexParameterfvRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)1880 void GL_APIENTRY GL_GetTexParameterfvRobustANGLE(GLenum target,
1881 GLenum pname,
1882 GLsizei bufSize,
1883 GLsizei *length,
1884 GLfloat *params)
1885 {
1886 Context *context = GetValidGlobalContext();
1887 EVENT(context, GLGetTexParameterfvRobustANGLE,
1888 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1889 ", params = 0x%016" PRIxPTR "",
1890 CID(context), GLenumToString(GLESEnum::AllEnums, target),
1891 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
1892
1893 if (context)
1894 {
1895 TextureType targetPacked = PackParam<TextureType>(target);
1896 SCOPED_SHARE_CONTEXT_LOCK(context);
1897 bool isCallValid = (context->skipValidation() ||
1898 ValidateGetTexParameterfvRobustANGLE(
1899 context, angle::EntryPoint::GLGetTexParameterfvRobustANGLE,
1900 targetPacked, pname, bufSize, length, params));
1901 if (isCallValid)
1902 {
1903 context->getTexParameterfvRobust(targetPacked, pname, bufSize, length, params);
1904 }
1905 ANGLE_CAPTURE_GL(GetTexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname,
1906 bufSize, length, params);
1907 }
1908 else
1909 {
1910 GenerateContextLostErrorOnCurrentGlobalContext();
1911 }
1912 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1913 }
1914
GL_GetTexParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)1915 void GL_APIENTRY GL_GetTexParameterivRobustANGLE(GLenum target,
1916 GLenum pname,
1917 GLsizei bufSize,
1918 GLsizei *length,
1919 GLint *params)
1920 {
1921 Context *context = GetValidGlobalContext();
1922 EVENT(context, GLGetTexParameterivRobustANGLE,
1923 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
1924 ", params = 0x%016" PRIxPTR "",
1925 CID(context), GLenumToString(GLESEnum::AllEnums, target),
1926 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
1927
1928 if (context)
1929 {
1930 TextureType targetPacked = PackParam<TextureType>(target);
1931 SCOPED_SHARE_CONTEXT_LOCK(context);
1932 bool isCallValid = (context->skipValidation() ||
1933 ValidateGetTexParameterivRobustANGLE(
1934 context, angle::EntryPoint::GLGetTexParameterivRobustANGLE,
1935 targetPacked, pname, bufSize, length, params));
1936 if (isCallValid)
1937 {
1938 context->getTexParameterivRobust(targetPacked, pname, bufSize, length, params);
1939 }
1940 ANGLE_CAPTURE_GL(GetTexParameterivRobustANGLE, isCallValid, context, targetPacked, pname,
1941 bufSize, length, params);
1942 }
1943 else
1944 {
1945 GenerateContextLostErrorOnCurrentGlobalContext();
1946 }
1947 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1948 }
1949
GL_GetUniformfvRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLfloat * params)1950 void GL_APIENTRY GL_GetUniformfvRobustANGLE(GLuint program,
1951 GLint location,
1952 GLsizei bufSize,
1953 GLsizei *length,
1954 GLfloat *params)
1955 {
1956 Context *context = GetValidGlobalContext();
1957 EVENT(context, GLGetUniformfvRobustANGLE,
1958 "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
1959 ", params = 0x%016" PRIxPTR "",
1960 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
1961
1962 if (context)
1963 {
1964 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1965 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1966 SCOPED_SHARE_CONTEXT_LOCK(context);
1967 bool isCallValid = (context->skipValidation() ||
1968 ValidateGetUniformfvRobustANGLE(
1969 context, angle::EntryPoint::GLGetUniformfvRobustANGLE,
1970 programPacked, locationPacked, bufSize, length, params));
1971 if (isCallValid)
1972 {
1973 context->getUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
1974 }
1975 ANGLE_CAPTURE_GL(GetUniformfvRobustANGLE, isCallValid, context, programPacked,
1976 locationPacked, bufSize, length, params);
1977 }
1978 else
1979 {
1980 GenerateContextLostErrorOnCurrentGlobalContext();
1981 }
1982 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
1983 }
1984
GL_GetUniformivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLint * params)1985 void GL_APIENTRY GL_GetUniformivRobustANGLE(GLuint program,
1986 GLint location,
1987 GLsizei bufSize,
1988 GLsizei *length,
1989 GLint *params)
1990 {
1991 Context *context = GetValidGlobalContext();
1992 EVENT(context, GLGetUniformivRobustANGLE,
1993 "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
1994 ", params = 0x%016" PRIxPTR "",
1995 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
1996
1997 if (context)
1998 {
1999 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2000 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2001 SCOPED_SHARE_CONTEXT_LOCK(context);
2002 bool isCallValid = (context->skipValidation() ||
2003 ValidateGetUniformivRobustANGLE(
2004 context, angle::EntryPoint::GLGetUniformivRobustANGLE,
2005 programPacked, locationPacked, bufSize, length, params));
2006 if (isCallValid)
2007 {
2008 context->getUniformivRobust(programPacked, locationPacked, bufSize, length, params);
2009 }
2010 ANGLE_CAPTURE_GL(GetUniformivRobustANGLE, isCallValid, context, programPacked,
2011 locationPacked, bufSize, length, params);
2012 }
2013 else
2014 {
2015 GenerateContextLostErrorOnCurrentGlobalContext();
2016 }
2017 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2018 }
2019
GL_GetVertexAttribfvRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)2020 void GL_APIENTRY GL_GetVertexAttribfvRobustANGLE(GLuint index,
2021 GLenum pname,
2022 GLsizei bufSize,
2023 GLsizei *length,
2024 GLfloat *params)
2025 {
2026 Context *context = GetValidGlobalContext();
2027 EVENT(context, GLGetVertexAttribfvRobustANGLE,
2028 "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2029 ", params = 0x%016" PRIxPTR "",
2030 CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
2031 (uintptr_t)length, (uintptr_t)params);
2032
2033 if (context)
2034 {
2035 SCOPED_SHARE_CONTEXT_LOCK(context);
2036 bool isCallValid = (context->skipValidation() ||
2037 ValidateGetVertexAttribfvRobustANGLE(
2038 context, angle::EntryPoint::GLGetVertexAttribfvRobustANGLE, index,
2039 pname, bufSize, length, params));
2040 if (isCallValid)
2041 {
2042 context->getVertexAttribfvRobust(index, pname, bufSize, length, params);
2043 }
2044 ANGLE_CAPTURE_GL(GetVertexAttribfvRobustANGLE, isCallValid, context, index, pname, bufSize,
2045 length, params);
2046 }
2047 else
2048 {
2049 GenerateContextLostErrorOnCurrentGlobalContext();
2050 }
2051 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2052 }
2053
GL_GetVertexAttribivRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2054 void GL_APIENTRY GL_GetVertexAttribivRobustANGLE(GLuint index,
2055 GLenum pname,
2056 GLsizei bufSize,
2057 GLsizei *length,
2058 GLint *params)
2059 {
2060 Context *context = GetValidGlobalContext();
2061 EVENT(context, GLGetVertexAttribivRobustANGLE,
2062 "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2063 ", params = 0x%016" PRIxPTR "",
2064 CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
2065 (uintptr_t)length, (uintptr_t)params);
2066
2067 if (context)
2068 {
2069 SCOPED_SHARE_CONTEXT_LOCK(context);
2070 bool isCallValid = (context->skipValidation() ||
2071 ValidateGetVertexAttribivRobustANGLE(
2072 context, angle::EntryPoint::GLGetVertexAttribivRobustANGLE, index,
2073 pname, bufSize, length, params));
2074 if (isCallValid)
2075 {
2076 context->getVertexAttribivRobust(index, pname, bufSize, length, params);
2077 }
2078 ANGLE_CAPTURE_GL(GetVertexAttribivRobustANGLE, isCallValid, context, index, pname, bufSize,
2079 length, params);
2080 }
2081 else
2082 {
2083 GenerateContextLostErrorOnCurrentGlobalContext();
2084 }
2085 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2086 }
2087
GL_GetVertexAttribPointervRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,void ** pointer)2088 void GL_APIENTRY GL_GetVertexAttribPointervRobustANGLE(GLuint index,
2089 GLenum pname,
2090 GLsizei bufSize,
2091 GLsizei *length,
2092 void **pointer)
2093 {
2094 Context *context = GetValidGlobalContext();
2095 EVENT(context, GLGetVertexAttribPointervRobustANGLE,
2096 "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2097 ", pointer = 0x%016" PRIxPTR "",
2098 CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
2099 (uintptr_t)length, (uintptr_t)pointer);
2100
2101 if (context)
2102 {
2103 SCOPED_SHARE_CONTEXT_LOCK(context);
2104 bool isCallValid = (context->skipValidation() ||
2105 ValidateGetVertexAttribPointervRobustANGLE(
2106 context, angle::EntryPoint::GLGetVertexAttribPointervRobustANGLE,
2107 index, pname, bufSize, length, pointer));
2108 if (isCallValid)
2109 {
2110 context->getVertexAttribPointervRobust(index, pname, bufSize, length, pointer);
2111 }
2112 ANGLE_CAPTURE_GL(GetVertexAttribPointervRobustANGLE, isCallValid, context, index, pname,
2113 bufSize, length, pointer);
2114 }
2115 else
2116 {
2117 GenerateContextLostErrorOnCurrentGlobalContext();
2118 }
2119 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2120 }
2121
GL_ReadPixelsRobustANGLE(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLsizei * length,GLsizei * columns,GLsizei * rows,void * pixels)2122 void GL_APIENTRY GL_ReadPixelsRobustANGLE(GLint x,
2123 GLint y,
2124 GLsizei width,
2125 GLsizei height,
2126 GLenum format,
2127 GLenum type,
2128 GLsizei bufSize,
2129 GLsizei *length,
2130 GLsizei *columns,
2131 GLsizei *rows,
2132 void *pixels)
2133 {
2134 Context *context = GetValidGlobalContext();
2135 EVENT(context, GLReadPixelsRobustANGLE,
2136 "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize "
2137 "= %d, length = 0x%016" PRIxPTR ", columns = 0x%016" PRIxPTR ", rows = 0x%016" PRIxPTR
2138 ", pixels = 0x%016" PRIxPTR "",
2139 CID(context), x, y, width, height, GLenumToString(GLESEnum::AllEnums, format),
2140 GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)length, (uintptr_t)columns,
2141 (uintptr_t)rows, (uintptr_t)pixels);
2142
2143 if (context)
2144 {
2145 SCOPED_SHARE_CONTEXT_LOCK(context);
2146 bool isCallValid =
2147 (context->skipValidation() ||
2148 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2149 context->getMutableErrorSetForValidation(),
2150 angle::EntryPoint::GLReadPixelsRobustANGLE) &&
2151 ValidateReadPixelsRobustANGLE(context, angle::EntryPoint::GLReadPixelsRobustANGLE, x,
2152 y, width, height, format, type, bufSize, length,
2153 columns, rows, pixels)));
2154 if (isCallValid)
2155 {
2156 context->readPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
2157 rows, pixels);
2158 }
2159 ANGLE_CAPTURE_GL(ReadPixelsRobustANGLE, isCallValid, context, x, y, width, height, format,
2160 type, bufSize, length, columns, rows, pixels);
2161 }
2162 else
2163 {
2164 GenerateContextLostErrorOnCurrentGlobalContext();
2165 }
2166 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2167 }
2168
GL_TexImage2DRobustANGLE(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)2169 void GL_APIENTRY GL_TexImage2DRobustANGLE(GLenum target,
2170 GLint level,
2171 GLint internalformat,
2172 GLsizei width,
2173 GLsizei height,
2174 GLint border,
2175 GLenum format,
2176 GLenum type,
2177 GLsizei bufSize,
2178 const void *pixels)
2179 {
2180 Context *context = GetValidGlobalContext();
2181 EVENT(context, GLTexImage2DRobustANGLE,
2182 "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, "
2183 "border = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "",
2184 CID(context), GLenumToString(GLESEnum::AllEnums, target), level, internalformat, width,
2185 height, border, GLenumToString(GLESEnum::AllEnums, format),
2186 GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)pixels);
2187
2188 if (context)
2189 {
2190 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2191 SCOPED_SHARE_CONTEXT_LOCK(context);
2192 bool isCallValid =
2193 (context->skipValidation() ||
2194 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2195 context->getMutableErrorSetForValidation(),
2196 angle::EntryPoint::GLTexImage2DRobustANGLE) &&
2197 ValidateTexImage2DRobustANGLE(context, angle::EntryPoint::GLTexImage2DRobustANGLE,
2198 targetPacked, level, internalformat, width, height,
2199 border, format, type, bufSize, pixels)));
2200 if (isCallValid)
2201 {
2202 context->texImage2DRobust(targetPacked, level, internalformat, width, height, border,
2203 format, type, bufSize, pixels);
2204 }
2205 ANGLE_CAPTURE_GL(TexImage2DRobustANGLE, isCallValid, context, targetPacked, level,
2206 internalformat, width, height, border, format, type, bufSize, pixels);
2207 }
2208 else
2209 {
2210 GenerateContextLostErrorOnCurrentGlobalContext();
2211 }
2212 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
2213 }
2214
GL_TexParameterfvRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLfloat * params)2215 void GL_APIENTRY GL_TexParameterfvRobustANGLE(GLenum target,
2216 GLenum pname,
2217 GLsizei bufSize,
2218 const GLfloat *params)
2219 {
2220 Context *context = GetValidGlobalContext();
2221 EVENT(context, GLTexParameterfvRobustANGLE,
2222 "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "",
2223 CID(context), GLenumToString(GLESEnum::AllEnums, target),
2224 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)params);
2225
2226 if (context)
2227 {
2228 TextureType targetPacked = PackParam<TextureType>(target);
2229 SCOPED_SHARE_CONTEXT_LOCK(context);
2230 bool isCallValid = (context->skipValidation() ||
2231 ValidateTexParameterfvRobustANGLE(
2232 context, angle::EntryPoint::GLTexParameterfvRobustANGLE,
2233 targetPacked, pname, bufSize, params));
2234 if (isCallValid)
2235 {
2236 context->texParameterfvRobust(targetPacked, pname, bufSize, params);
2237 }
2238 ANGLE_CAPTURE_GL(TexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname,
2239 bufSize, params);
2240 }
2241 else
2242 {
2243 GenerateContextLostErrorOnCurrentGlobalContext();
2244 }
2245 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2246 }
2247
GL_TexParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLint * params)2248 void GL_APIENTRY GL_TexParameterivRobustANGLE(GLenum target,
2249 GLenum pname,
2250 GLsizei bufSize,
2251 const GLint *params)
2252 {
2253 Context *context = GetValidGlobalContext();
2254 EVENT(context, GLTexParameterivRobustANGLE,
2255 "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "",
2256 CID(context), GLenumToString(GLESEnum::AllEnums, target),
2257 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)params);
2258
2259 if (context)
2260 {
2261 TextureType targetPacked = PackParam<TextureType>(target);
2262 SCOPED_SHARE_CONTEXT_LOCK(context);
2263 bool isCallValid = (context->skipValidation() ||
2264 ValidateTexParameterivRobustANGLE(
2265 context, angle::EntryPoint::GLTexParameterivRobustANGLE,
2266 targetPacked, pname, bufSize, params));
2267 if (isCallValid)
2268 {
2269 context->texParameterivRobust(targetPacked, pname, bufSize, params);
2270 }
2271 ANGLE_CAPTURE_GL(TexParameterivRobustANGLE, isCallValid, context, targetPacked, pname,
2272 bufSize, params);
2273 }
2274 else
2275 {
2276 GenerateContextLostErrorOnCurrentGlobalContext();
2277 }
2278 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2279 }
2280
GL_TexSubImage2DRobustANGLE(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)2281 void GL_APIENTRY GL_TexSubImage2DRobustANGLE(GLenum target,
2282 GLint level,
2283 GLint xoffset,
2284 GLint yoffset,
2285 GLsizei width,
2286 GLsizei height,
2287 GLenum format,
2288 GLenum type,
2289 GLsizei bufSize,
2290 const void *pixels)
2291 {
2292 Context *context = GetValidGlobalContext();
2293 EVENT(context, GLTexSubImage2DRobustANGLE,
2294 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = "
2295 "%d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "",
2296 CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, width,
2297 height, GLenumToString(GLESEnum::AllEnums, format),
2298 GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)pixels);
2299
2300 if (context)
2301 {
2302 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2303 SCOPED_SHARE_CONTEXT_LOCK(context);
2304 bool isCallValid =
2305 (context->skipValidation() ||
2306 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2307 context->getMutableErrorSetForValidation(),
2308 angle::EntryPoint::GLTexSubImage2DRobustANGLE) &&
2309 ValidateTexSubImage2DRobustANGLE(
2310 context, angle::EntryPoint::GLTexSubImage2DRobustANGLE, targetPacked, level,
2311 xoffset, yoffset, width, height, format, type, bufSize, pixels)));
2312 if (isCallValid)
2313 {
2314 context->texSubImage2DRobust(targetPacked, level, xoffset, yoffset, width, height,
2315 format, type, bufSize, pixels);
2316 }
2317 ANGLE_CAPTURE_GL(TexSubImage2DRobustANGLE, isCallValid, context, targetPacked, level,
2318 xoffset, yoffset, width, height, format, type, bufSize, pixels);
2319 }
2320 else
2321 {
2322 GenerateContextLostErrorOnCurrentGlobalContext();
2323 }
2324 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
2325 }
2326
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)2327 void GL_APIENTRY GL_TexImage3DRobustANGLE(GLenum target,
2328 GLint level,
2329 GLint internalformat,
2330 GLsizei width,
2331 GLsizei height,
2332 GLsizei depth,
2333 GLint border,
2334 GLenum format,
2335 GLenum type,
2336 GLsizei bufSize,
2337 const void *pixels)
2338 {
2339 Context *context = GetValidGlobalContext();
2340 EVENT(context, GLTexImage3DRobustANGLE,
2341 "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, "
2342 "depth = %d, border = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR
2343 "",
2344 CID(context), GLenumToString(GLESEnum::AllEnums, target), level, internalformat, width,
2345 height, depth, border, GLenumToString(GLESEnum::AllEnums, format),
2346 GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)pixels);
2347
2348 if (context)
2349 {
2350 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2351 SCOPED_SHARE_CONTEXT_LOCK(context);
2352 bool isCallValid =
2353 (context->skipValidation() ||
2354 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2355 context->getMutableErrorSetForValidation(),
2356 angle::EntryPoint::GLTexImage3DRobustANGLE) &&
2357 ValidateTexImage3DRobustANGLE(context, angle::EntryPoint::GLTexImage3DRobustANGLE,
2358 targetPacked, level, internalformat, width, height,
2359 depth, border, format, type, bufSize, pixels)));
2360 if (isCallValid)
2361 {
2362 context->texImage3DRobust(targetPacked, level, internalformat, width, height, depth,
2363 border, format, type, bufSize, pixels);
2364 }
2365 ANGLE_CAPTURE_GL(TexImage3DRobustANGLE, isCallValid, context, targetPacked, level,
2366 internalformat, width, height, depth, border, format, type, bufSize,
2367 pixels);
2368 }
2369 else
2370 {
2371 GenerateContextLostErrorOnCurrentGlobalContext();
2372 }
2373 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
2374 }
2375
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)2376 void GL_APIENTRY GL_TexSubImage3DRobustANGLE(GLenum target,
2377 GLint level,
2378 GLint xoffset,
2379 GLint yoffset,
2380 GLint zoffset,
2381 GLsizei width,
2382 GLsizei height,
2383 GLsizei depth,
2384 GLenum format,
2385 GLenum type,
2386 GLsizei bufSize,
2387 const void *pixels)
2388 {
2389 Context *context = GetValidGlobalContext();
2390 EVENT(
2391 context, GLTexSubImage3DRobustANGLE,
2392 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width = "
2393 "%d, height = %d, depth = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR
2394 "",
2395 CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, zoffset,
2396 width, height, depth, GLenumToString(GLESEnum::AllEnums, format),
2397 GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)pixels);
2398
2399 if (context)
2400 {
2401 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2402 SCOPED_SHARE_CONTEXT_LOCK(context);
2403 bool isCallValid =
2404 (context->skipValidation() ||
2405 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
2406 context->getMutableErrorSetForValidation(),
2407 angle::EntryPoint::GLTexSubImage3DRobustANGLE) &&
2408 ValidateTexSubImage3DRobustANGLE(
2409 context, angle::EntryPoint::GLTexSubImage3DRobustANGLE, targetPacked, level,
2410 xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels)));
2411 if (isCallValid)
2412 {
2413 context->texSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset, width,
2414 height, depth, format, type, bufSize, pixels);
2415 }
2416 ANGLE_CAPTURE_GL(TexSubImage3DRobustANGLE, isCallValid, context, targetPacked, level,
2417 xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize,
2418 pixels);
2419 }
2420 else
2421 {
2422 GenerateContextLostErrorOnCurrentGlobalContext();
2423 }
2424 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
2425 }
2426
GL_CompressedTexImage2DRobustANGLE(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,GLsizei dataSize,const void * data)2427 void GL_APIENTRY GL_CompressedTexImage2DRobustANGLE(GLenum target,
2428 GLint level,
2429 GLenum internalformat,
2430 GLsizei width,
2431 GLsizei height,
2432 GLint border,
2433 GLsizei imageSize,
2434 GLsizei dataSize,
2435 const void *data)
2436 {
2437 Context *context = GetValidGlobalContext();
2438 EVENT(context, GLCompressedTexImage2DRobustANGLE,
2439 "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
2440 "border = %d, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "",
2441 CID(context), GLenumToString(GLESEnum::AllEnums, target), level,
2442 GLenumToString(GLESEnum::AllEnums, internalformat), width, height, border, imageSize,
2443 dataSize, (uintptr_t)data);
2444
2445 if (context)
2446 {
2447 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2448 SCOPED_SHARE_CONTEXT_LOCK(context);
2449 bool isCallValid =
2450 (context->skipValidation() ||
2451 (ValidatePixelLocalStorageInactive(
2452 context->getPrivateState(), context->getMutableErrorSetForValidation(),
2453 angle::EntryPoint::GLCompressedTexImage2DRobustANGLE) &&
2454 ValidateCompressedTexImage2DRobustANGLE(
2455 context, angle::EntryPoint::GLCompressedTexImage2DRobustANGLE, targetPacked,
2456 level, internalformat, width, height, border, imageSize, dataSize, data)));
2457 if (isCallValid)
2458 {
2459 context->compressedTexImage2DRobust(targetPacked, level, internalformat, width, height,
2460 border, imageSize, dataSize, data);
2461 }
2462 ANGLE_CAPTURE_GL(CompressedTexImage2DRobustANGLE, isCallValid, context, targetPacked, level,
2463 internalformat, width, height, border, imageSize, dataSize, data);
2464 }
2465 else
2466 {
2467 GenerateContextLostErrorOnCurrentGlobalContext();
2468 }
2469 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
2470 }
2471
GL_CompressedTexSubImage2DRobustANGLE(GLenum target,GLint level,GLsizei xoffset,GLsizei yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,GLsizei dataSize,const void * data)2472 void GL_APIENTRY GL_CompressedTexSubImage2DRobustANGLE(GLenum target,
2473 GLint level,
2474 GLsizei xoffset,
2475 GLsizei yoffset,
2476 GLsizei width,
2477 GLsizei height,
2478 GLenum format,
2479 GLsizei imageSize,
2480 GLsizei dataSize,
2481 const void *data)
2482 {
2483 Context *context = GetValidGlobalContext();
2484 EVENT(context, GLCompressedTexSubImage2DRobustANGLE,
2485 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = "
2486 "%d, format = %s, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "",
2487 CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, width,
2488 height, GLenumToString(GLESEnum::AllEnums, format), imageSize, dataSize, (uintptr_t)data);
2489
2490 if (context)
2491 {
2492 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2493 SCOPED_SHARE_CONTEXT_LOCK(context);
2494 bool isCallValid =
2495 (context->skipValidation() ||
2496 (ValidatePixelLocalStorageInactive(
2497 context->getPrivateState(), context->getMutableErrorSetForValidation(),
2498 angle::EntryPoint::GLCompressedTexSubImage2DRobustANGLE) &&
2499 ValidateCompressedTexSubImage2DRobustANGLE(
2500 context, angle::EntryPoint::GLCompressedTexSubImage2DRobustANGLE, targetPacked,
2501 level, xoffset, yoffset, width, height, format, imageSize, dataSize, data)));
2502 if (isCallValid)
2503 {
2504 context->compressedTexSubImage2DRobust(targetPacked, level, xoffset, yoffset, width,
2505 height, format, imageSize, dataSize, data);
2506 }
2507 ANGLE_CAPTURE_GL(CompressedTexSubImage2DRobustANGLE, isCallValid, context, targetPacked,
2508 level, xoffset, yoffset, width, height, format, imageSize, dataSize, data);
2509 }
2510 else
2511 {
2512 GenerateContextLostErrorOnCurrentGlobalContext();
2513 }
2514 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
2515 }
2516
GL_CompressedTexImage3DRobustANGLE(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,GLsizei dataSize,const void * data)2517 void GL_APIENTRY GL_CompressedTexImage3DRobustANGLE(GLenum target,
2518 GLint level,
2519 GLenum internalformat,
2520 GLsizei width,
2521 GLsizei height,
2522 GLsizei depth,
2523 GLint border,
2524 GLsizei imageSize,
2525 GLsizei dataSize,
2526 const void *data)
2527 {
2528 Context *context = GetValidGlobalContext();
2529 EVENT(context, GLCompressedTexImage3DRobustANGLE,
2530 "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
2531 "depth = %d, border = %d, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "",
2532 CID(context), GLenumToString(GLESEnum::AllEnums, target), level,
2533 GLenumToString(GLESEnum::AllEnums, internalformat), width, height, depth, border,
2534 imageSize, dataSize, (uintptr_t)data);
2535
2536 if (context)
2537 {
2538 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2539 SCOPED_SHARE_CONTEXT_LOCK(context);
2540 bool isCallValid =
2541 (context->skipValidation() ||
2542 (ValidatePixelLocalStorageInactive(
2543 context->getPrivateState(), context->getMutableErrorSetForValidation(),
2544 angle::EntryPoint::GLCompressedTexImage3DRobustANGLE) &&
2545 ValidateCompressedTexImage3DRobustANGLE(
2546 context, angle::EntryPoint::GLCompressedTexImage3DRobustANGLE, targetPacked,
2547 level, internalformat, width, height, depth, border, imageSize, dataSize, data)));
2548 if (isCallValid)
2549 {
2550 context->compressedTexImage3DRobust(targetPacked, level, internalformat, width, height,
2551 depth, border, imageSize, dataSize, data);
2552 }
2553 ANGLE_CAPTURE_GL(CompressedTexImage3DRobustANGLE, isCallValid, context, targetPacked, level,
2554 internalformat, width, height, depth, border, imageSize, dataSize, data);
2555 }
2556 else
2557 {
2558 GenerateContextLostErrorOnCurrentGlobalContext();
2559 }
2560 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
2561 }
2562
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 void * data)2563 void GL_APIENTRY GL_CompressedTexSubImage3DRobustANGLE(GLenum target,
2564 GLint level,
2565 GLint xoffset,
2566 GLint yoffset,
2567 GLint zoffset,
2568 GLsizei width,
2569 GLsizei height,
2570 GLsizei depth,
2571 GLenum format,
2572 GLsizei imageSize,
2573 GLsizei dataSize,
2574 const void *data)
2575 {
2576 Context *context = GetValidGlobalContext();
2577 EVENT(context, GLCompressedTexSubImage3DRobustANGLE,
2578 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width "
2579 "= %d, height = %d, depth = %d, format = %s, imageSize = %d, dataSize = %d, data = "
2580 "0x%016" PRIxPTR "",
2581 CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset,
2582 zoffset, width, height, depth, GLenumToString(GLESEnum::AllEnums, format), imageSize,
2583 dataSize, (uintptr_t)data);
2584
2585 if (context)
2586 {
2587 TextureTarget targetPacked = PackParam<TextureTarget>(target);
2588 SCOPED_SHARE_CONTEXT_LOCK(context);
2589 bool isCallValid =
2590 (context->skipValidation() ||
2591 (ValidatePixelLocalStorageInactive(
2592 context->getPrivateState(), context->getMutableErrorSetForValidation(),
2593 angle::EntryPoint::GLCompressedTexSubImage3DRobustANGLE) &&
2594 ValidateCompressedTexSubImage3DRobustANGLE(
2595 context, angle::EntryPoint::GLCompressedTexSubImage3DRobustANGLE, targetPacked,
2596 level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize,
2597 dataSize, data)));
2598 if (isCallValid)
2599 {
2600 context->compressedTexSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset,
2601 width, height, depth, format, imageSize,
2602 dataSize, data);
2603 }
2604 ANGLE_CAPTURE_GL(CompressedTexSubImage3DRobustANGLE, isCallValid, context, targetPacked,
2605 level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize,
2606 dataSize, data);
2607 }
2608 else
2609 {
2610 GenerateContextLostErrorOnCurrentGlobalContext();
2611 }
2612 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
2613 }
2614
GL_GetQueryivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2615 void GL_APIENTRY GL_GetQueryivRobustANGLE(GLenum target,
2616 GLenum pname,
2617 GLsizei bufSize,
2618 GLsizei *length,
2619 GLint *params)
2620 {
2621 Context *context = GetValidGlobalContext();
2622 EVENT(context, GLGetQueryivRobustANGLE,
2623 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2624 ", params = 0x%016" PRIxPTR "",
2625 CID(context), GLenumToString(GLESEnum::AllEnums, target),
2626 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
2627
2628 if (context)
2629 {
2630 QueryType targetPacked = PackParam<QueryType>(target);
2631 SCOPED_SHARE_CONTEXT_LOCK(context);
2632 bool isCallValid =
2633 (context->skipValidation() ||
2634 ValidateGetQueryivRobustANGLE(context, angle::EntryPoint::GLGetQueryivRobustANGLE,
2635 targetPacked, pname, bufSize, length, params));
2636 if (isCallValid)
2637 {
2638 context->getQueryivRobust(targetPacked, pname, bufSize, length, params);
2639 }
2640 ANGLE_CAPTURE_GL(GetQueryivRobustANGLE, isCallValid, context, targetPacked, pname, bufSize,
2641 length, params);
2642 }
2643 else
2644 {
2645 GenerateContextLostErrorOnCurrentGlobalContext();
2646 }
2647 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2648 }
2649
GL_GetQueryObjectuivRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2650 void GL_APIENTRY GL_GetQueryObjectuivRobustANGLE(GLuint id,
2651 GLenum pname,
2652 GLsizei bufSize,
2653 GLsizei *length,
2654 GLuint *params)
2655 {
2656 Context *context = GetValidGlobalContext();
2657 EVENT(context, GLGetQueryObjectuivRobustANGLE,
2658 "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2659 ", params = 0x%016" PRIxPTR "",
2660 CID(context), id, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length,
2661 (uintptr_t)params);
2662
2663 if (context)
2664 {
2665 QueryID idPacked = PackParam<QueryID>(id);
2666 SCOPED_SHARE_CONTEXT_LOCK(context);
2667 bool isCallValid = (context->skipValidation() ||
2668 ValidateGetQueryObjectuivRobustANGLE(
2669 context, angle::EntryPoint::GLGetQueryObjectuivRobustANGLE,
2670 idPacked, pname, bufSize, length, params));
2671 if (isCallValid)
2672 {
2673 context->getQueryObjectuivRobust(idPacked, pname, bufSize, length, params);
2674 }
2675 ANGLE_CAPTURE_GL(GetQueryObjectuivRobustANGLE, isCallValid, context, idPacked, pname,
2676 bufSize, length, params);
2677 }
2678 else
2679 {
2680 GenerateContextLostErrorOnCurrentGlobalContext();
2681 }
2682 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2683 }
2684
GL_GetBufferPointervRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)2685 void GL_APIENTRY GL_GetBufferPointervRobustANGLE(GLenum target,
2686 GLenum pname,
2687 GLsizei bufSize,
2688 GLsizei *length,
2689 void **params)
2690 {
2691 Context *context = GetValidGlobalContext();
2692 EVENT(context, GLGetBufferPointervRobustANGLE,
2693 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2694 ", params = 0x%016" PRIxPTR "",
2695 CID(context), GLenumToString(GLESEnum::AllEnums, target),
2696 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
2697
2698 if (context)
2699 {
2700 BufferBinding targetPacked = PackParam<BufferBinding>(target);
2701 SCOPED_SHARE_CONTEXT_LOCK(context);
2702 bool isCallValid = (context->skipValidation() ||
2703 ValidateGetBufferPointervRobustANGLE(
2704 context, angle::EntryPoint::GLGetBufferPointervRobustANGLE,
2705 targetPacked, pname, bufSize, length, params));
2706 if (isCallValid)
2707 {
2708 context->getBufferPointervRobust(targetPacked, pname, bufSize, length, params);
2709 }
2710 ANGLE_CAPTURE_GL(GetBufferPointervRobustANGLE, isCallValid, context, targetPacked, pname,
2711 bufSize, length, params);
2712 }
2713 else
2714 {
2715 GenerateContextLostErrorOnCurrentGlobalContext();
2716 }
2717 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2718 }
2719
GL_GetIntegeri_vRobustANGLE(GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint * data)2720 void GL_APIENTRY GL_GetIntegeri_vRobustANGLE(GLenum target,
2721 GLuint index,
2722 GLsizei bufSize,
2723 GLsizei *length,
2724 GLint *data)
2725 {
2726 Context *context = GetValidGlobalContext();
2727 EVENT(context, GLGetIntegeri_vRobustANGLE,
2728 "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
2729 ", data = 0x%016" PRIxPTR "",
2730 CID(context), GLenumToString(GLESEnum::AllEnums, target), index, bufSize,
2731 (uintptr_t)length, (uintptr_t)data);
2732
2733 if (context)
2734 {
2735 SCOPED_SHARE_CONTEXT_LOCK(context);
2736 bool isCallValid = (context->skipValidation() ||
2737 ValidateGetIntegeri_vRobustANGLE(
2738 context, angle::EntryPoint::GLGetIntegeri_vRobustANGLE, target,
2739 index, bufSize, length, data));
2740 if (isCallValid)
2741 {
2742 context->getIntegeri_vRobust(target, index, bufSize, length, data);
2743 }
2744 ANGLE_CAPTURE_GL(GetIntegeri_vRobustANGLE, isCallValid, context, target, index, bufSize,
2745 length, data);
2746 }
2747 else
2748 {
2749 GenerateContextLostErrorOnCurrentGlobalContext();
2750 }
2751 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2752 }
2753
GL_GetInternalformativRobustANGLE(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2754 void GL_APIENTRY GL_GetInternalformativRobustANGLE(GLenum target,
2755 GLenum internalformat,
2756 GLenum pname,
2757 GLsizei bufSize,
2758 GLsizei *length,
2759 GLint *params)
2760 {
2761 Context *context = GetValidGlobalContext();
2762 EVENT(context, GLGetInternalformativRobustANGLE,
2763 "context = %d, target = %s, internalformat = %s, pname = %s, bufSize = %d, length = "
2764 "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
2765 CID(context), GLenumToString(GLESEnum::AllEnums, target),
2766 GLenumToString(GLESEnum::AllEnums, internalformat),
2767 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
2768
2769 if (context)
2770 {
2771 SCOPED_SHARE_CONTEXT_LOCK(context);
2772 bool isCallValid = (context->skipValidation() ||
2773 ValidateGetInternalformativRobustANGLE(
2774 context, angle::EntryPoint::GLGetInternalformativRobustANGLE,
2775 target, internalformat, pname, bufSize, length, params));
2776 if (isCallValid)
2777 {
2778 context->getInternalformativRobust(target, internalformat, pname, bufSize, length,
2779 params);
2780 }
2781 ANGLE_CAPTURE_GL(GetInternalformativRobustANGLE, isCallValid, context, target,
2782 internalformat, pname, bufSize, length, params);
2783 }
2784 else
2785 {
2786 GenerateContextLostErrorOnCurrentGlobalContext();
2787 }
2788 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2789 }
2790
GL_GetVertexAttribIivRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2791 void GL_APIENTRY GL_GetVertexAttribIivRobustANGLE(GLuint index,
2792 GLenum pname,
2793 GLsizei bufSize,
2794 GLsizei *length,
2795 GLint *params)
2796 {
2797 Context *context = GetValidGlobalContext();
2798 EVENT(context, GLGetVertexAttribIivRobustANGLE,
2799 "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2800 ", params = 0x%016" PRIxPTR "",
2801 CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
2802 (uintptr_t)length, (uintptr_t)params);
2803
2804 if (context)
2805 {
2806 SCOPED_SHARE_CONTEXT_LOCK(context);
2807 bool isCallValid = (context->skipValidation() ||
2808 ValidateGetVertexAttribIivRobustANGLE(
2809 context, angle::EntryPoint::GLGetVertexAttribIivRobustANGLE, index,
2810 pname, bufSize, length, params));
2811 if (isCallValid)
2812 {
2813 context->getVertexAttribIivRobust(index, pname, bufSize, length, params);
2814 }
2815 ANGLE_CAPTURE_GL(GetVertexAttribIivRobustANGLE, isCallValid, context, index, pname, bufSize,
2816 length, params);
2817 }
2818 else
2819 {
2820 GenerateContextLostErrorOnCurrentGlobalContext();
2821 }
2822 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2823 }
2824
GL_GetVertexAttribIuivRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2825 void GL_APIENTRY GL_GetVertexAttribIuivRobustANGLE(GLuint index,
2826 GLenum pname,
2827 GLsizei bufSize,
2828 GLsizei *length,
2829 GLuint *params)
2830 {
2831 Context *context = GetValidGlobalContext();
2832 EVENT(context, GLGetVertexAttribIuivRobustANGLE,
2833 "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2834 ", params = 0x%016" PRIxPTR "",
2835 CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
2836 (uintptr_t)length, (uintptr_t)params);
2837
2838 if (context)
2839 {
2840 SCOPED_SHARE_CONTEXT_LOCK(context);
2841 bool isCallValid = (context->skipValidation() ||
2842 ValidateGetVertexAttribIuivRobustANGLE(
2843 context, angle::EntryPoint::GLGetVertexAttribIuivRobustANGLE, index,
2844 pname, bufSize, length, params));
2845 if (isCallValid)
2846 {
2847 context->getVertexAttribIuivRobust(index, pname, bufSize, length, params);
2848 }
2849 ANGLE_CAPTURE_GL(GetVertexAttribIuivRobustANGLE, isCallValid, context, index, pname,
2850 bufSize, length, params);
2851 }
2852 else
2853 {
2854 GenerateContextLostErrorOnCurrentGlobalContext();
2855 }
2856 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2857 }
2858
GL_GetUniformuivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLuint * params)2859 void GL_APIENTRY GL_GetUniformuivRobustANGLE(GLuint program,
2860 GLint location,
2861 GLsizei bufSize,
2862 GLsizei *length,
2863 GLuint *params)
2864 {
2865 Context *context = GetValidGlobalContext();
2866 EVENT(context, GLGetUniformuivRobustANGLE,
2867 "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
2868 ", params = 0x%016" PRIxPTR "",
2869 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
2870
2871 if (context)
2872 {
2873 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2874 UniformLocation locationPacked = PackParam<UniformLocation>(location);
2875 SCOPED_SHARE_CONTEXT_LOCK(context);
2876 bool isCallValid = (context->skipValidation() ||
2877 ValidateGetUniformuivRobustANGLE(
2878 context, angle::EntryPoint::GLGetUniformuivRobustANGLE,
2879 programPacked, locationPacked, bufSize, length, params));
2880 if (isCallValid)
2881 {
2882 context->getUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
2883 }
2884 ANGLE_CAPTURE_GL(GetUniformuivRobustANGLE, isCallValid, context, programPacked,
2885 locationPacked, bufSize, length, params);
2886 }
2887 else
2888 {
2889 GenerateContextLostErrorOnCurrentGlobalContext();
2890 }
2891 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2892 }
2893
GL_GetActiveUniformBlockivRobustANGLE(GLuint program,GLuint uniformBlockIndex,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2894 void GL_APIENTRY GL_GetActiveUniformBlockivRobustANGLE(GLuint program,
2895 GLuint uniformBlockIndex,
2896 GLenum pname,
2897 GLsizei bufSize,
2898 GLsizei *length,
2899 GLint *params)
2900 {
2901 Context *context = GetValidGlobalContext();
2902 EVENT(context, GLGetActiveUniformBlockivRobustANGLE,
2903 "context = %d, program = %u, uniformBlockIndex = %u, pname = %s, bufSize = %d, length = "
2904 "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
2905 CID(context), program, uniformBlockIndex, GLenumToString(GLESEnum::AllEnums, pname),
2906 bufSize, (uintptr_t)length, (uintptr_t)params);
2907
2908 if (context)
2909 {
2910 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
2911 UniformBlockIndex uniformBlockIndexPacked = PackParam<UniformBlockIndex>(uniformBlockIndex);
2912 SCOPED_SHARE_CONTEXT_LOCK(context);
2913 bool isCallValid =
2914 (context->skipValidation() ||
2915 ValidateGetActiveUniformBlockivRobustANGLE(
2916 context, angle::EntryPoint::GLGetActiveUniformBlockivRobustANGLE, programPacked,
2917 uniformBlockIndexPacked, pname, bufSize, length, params));
2918 if (isCallValid)
2919 {
2920 context->getActiveUniformBlockivRobust(programPacked, uniformBlockIndexPacked, pname,
2921 bufSize, length, params);
2922 }
2923 ANGLE_CAPTURE_GL(GetActiveUniformBlockivRobustANGLE, isCallValid, context, programPacked,
2924 uniformBlockIndexPacked, pname, bufSize, length, params);
2925 }
2926 else
2927 {
2928 GenerateContextLostErrorOnCurrentGlobalContext();
2929 }
2930 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2931 }
2932
GL_GetInteger64vRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * data)2933 void GL_APIENTRY GL_GetInteger64vRobustANGLE(GLenum pname,
2934 GLsizei bufSize,
2935 GLsizei *length,
2936 GLint64 *data)
2937 {
2938 Context *context = GetValidGlobalContext();
2939 EVENT(context, GLGetInteger64vRobustANGLE,
2940 "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
2941 ", data = 0x%016" PRIxPTR "",
2942 CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length,
2943 (uintptr_t)data);
2944
2945 if (context)
2946 {
2947 SCOPED_SHARE_CONTEXT_LOCK(context);
2948 bool isCallValid = (context->skipValidation() ||
2949 ValidateGetInteger64vRobustANGLE(
2950 context, angle::EntryPoint::GLGetInteger64vRobustANGLE, pname,
2951 bufSize, length, data));
2952 if (isCallValid)
2953 {
2954 context->getInteger64vRobust(pname, bufSize, length, data);
2955 }
2956 ANGLE_CAPTURE_GL(GetInteger64vRobustANGLE, isCallValid, context, pname, bufSize, length,
2957 data);
2958 }
2959 else
2960 {
2961 GenerateContextLostErrorOnCurrentGlobalContext();
2962 }
2963 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2964 }
2965
GL_GetInteger64i_vRobustANGLE(GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint64 * data)2966 void GL_APIENTRY GL_GetInteger64i_vRobustANGLE(GLenum target,
2967 GLuint index,
2968 GLsizei bufSize,
2969 GLsizei *length,
2970 GLint64 *data)
2971 {
2972 Context *context = GetValidGlobalContext();
2973 EVENT(context, GLGetInteger64i_vRobustANGLE,
2974 "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
2975 ", data = 0x%016" PRIxPTR "",
2976 CID(context), GLenumToString(GLESEnum::AllEnums, target), index, bufSize,
2977 (uintptr_t)length, (uintptr_t)data);
2978
2979 if (context)
2980 {
2981 SCOPED_SHARE_CONTEXT_LOCK(context);
2982 bool isCallValid = (context->skipValidation() ||
2983 ValidateGetInteger64i_vRobustANGLE(
2984 context, angle::EntryPoint::GLGetInteger64i_vRobustANGLE, target,
2985 index, bufSize, length, data));
2986 if (isCallValid)
2987 {
2988 context->getInteger64i_vRobust(target, index, bufSize, length, data);
2989 }
2990 ANGLE_CAPTURE_GL(GetInteger64i_vRobustANGLE, isCallValid, context, target, index, bufSize,
2991 length, data);
2992 }
2993 else
2994 {
2995 GenerateContextLostErrorOnCurrentGlobalContext();
2996 }
2997 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
2998 }
2999
GL_GetBufferParameteri64vRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)3000 void GL_APIENTRY GL_GetBufferParameteri64vRobustANGLE(GLenum target,
3001 GLenum pname,
3002 GLsizei bufSize,
3003 GLsizei *length,
3004 GLint64 *params)
3005 {
3006 Context *context = GetValidGlobalContext();
3007 EVENT(context, GLGetBufferParameteri64vRobustANGLE,
3008 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3009 ", params = 0x%016" PRIxPTR "",
3010 CID(context), GLenumToString(GLESEnum::AllEnums, target),
3011 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
3012
3013 if (context)
3014 {
3015 BufferBinding targetPacked = PackParam<BufferBinding>(target);
3016 SCOPED_SHARE_CONTEXT_LOCK(context);
3017 bool isCallValid = (context->skipValidation() ||
3018 ValidateGetBufferParameteri64vRobustANGLE(
3019 context, angle::EntryPoint::GLGetBufferParameteri64vRobustANGLE,
3020 targetPacked, pname, bufSize, length, params));
3021 if (isCallValid)
3022 {
3023 context->getBufferParameteri64vRobust(targetPacked, pname, bufSize, length, params);
3024 }
3025 ANGLE_CAPTURE_GL(GetBufferParameteri64vRobustANGLE, isCallValid, context, targetPacked,
3026 pname, bufSize, length, params);
3027 }
3028 else
3029 {
3030 GenerateContextLostErrorOnCurrentGlobalContext();
3031 }
3032 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3033 }
3034
GL_SamplerParameterivRobustANGLE(GLuint sampler,GLuint pname,GLsizei bufSize,const GLint * param)3035 void GL_APIENTRY GL_SamplerParameterivRobustANGLE(GLuint sampler,
3036 GLuint pname,
3037 GLsizei bufSize,
3038 const GLint *param)
3039 {
3040 Context *context = GetValidGlobalContext();
3041 EVENT(context, GLSamplerParameterivRobustANGLE,
3042 "context = %d, sampler = %u, pname = %u, bufSize = %d, param = 0x%016" PRIxPTR "",
3043 CID(context), sampler, pname, bufSize, (uintptr_t)param);
3044
3045 if (context)
3046 {
3047 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
3048 SCOPED_SHARE_CONTEXT_LOCK(context);
3049 bool isCallValid = (context->skipValidation() ||
3050 ValidateSamplerParameterivRobustANGLE(
3051 context, angle::EntryPoint::GLSamplerParameterivRobustANGLE,
3052 samplerPacked, pname, bufSize, param));
3053 if (isCallValid)
3054 {
3055 context->samplerParameterivRobust(samplerPacked, pname, bufSize, param);
3056 }
3057 ANGLE_CAPTURE_GL(SamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, pname,
3058 bufSize, param);
3059 }
3060 else
3061 {
3062 GenerateContextLostErrorOnCurrentGlobalContext();
3063 }
3064 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3065 }
3066
GL_SamplerParameterfvRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLfloat * param)3067 void GL_APIENTRY GL_SamplerParameterfvRobustANGLE(GLuint sampler,
3068 GLenum pname,
3069 GLsizei bufSize,
3070 const GLfloat *param)
3071 {
3072 Context *context = GetValidGlobalContext();
3073 EVENT(context, GLSamplerParameterfvRobustANGLE,
3074 "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "",
3075 CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
3076 (uintptr_t)param);
3077
3078 if (context)
3079 {
3080 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
3081 SCOPED_SHARE_CONTEXT_LOCK(context);
3082 bool isCallValid = (context->skipValidation() ||
3083 ValidateSamplerParameterfvRobustANGLE(
3084 context, angle::EntryPoint::GLSamplerParameterfvRobustANGLE,
3085 samplerPacked, pname, bufSize, param));
3086 if (isCallValid)
3087 {
3088 context->samplerParameterfvRobust(samplerPacked, pname, bufSize, param);
3089 }
3090 ANGLE_CAPTURE_GL(SamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, pname,
3091 bufSize, param);
3092 }
3093 else
3094 {
3095 GenerateContextLostErrorOnCurrentGlobalContext();
3096 }
3097 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3098 }
3099
GL_GetSamplerParameterivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3100 void GL_APIENTRY GL_GetSamplerParameterivRobustANGLE(GLuint sampler,
3101 GLenum pname,
3102 GLsizei bufSize,
3103 GLsizei *length,
3104 GLint *params)
3105 {
3106 Context *context = GetValidGlobalContext();
3107 EVENT(context, GLGetSamplerParameterivRobustANGLE,
3108 "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3109 ", params = 0x%016" PRIxPTR "",
3110 CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
3111 (uintptr_t)length, (uintptr_t)params);
3112
3113 if (context)
3114 {
3115 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
3116 SCOPED_SHARE_CONTEXT_LOCK(context);
3117 bool isCallValid = (context->skipValidation() ||
3118 ValidateGetSamplerParameterivRobustANGLE(
3119 context, angle::EntryPoint::GLGetSamplerParameterivRobustANGLE,
3120 samplerPacked, pname, bufSize, length, params));
3121 if (isCallValid)
3122 {
3123 context->getSamplerParameterivRobust(samplerPacked, pname, bufSize, length, params);
3124 }
3125 ANGLE_CAPTURE_GL(GetSamplerParameterivRobustANGLE, isCallValid, context, samplerPacked,
3126 pname, bufSize, length, params);
3127 }
3128 else
3129 {
3130 GenerateContextLostErrorOnCurrentGlobalContext();
3131 }
3132 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3133 }
3134
GL_GetSamplerParameterfvRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)3135 void GL_APIENTRY GL_GetSamplerParameterfvRobustANGLE(GLuint sampler,
3136 GLenum pname,
3137 GLsizei bufSize,
3138 GLsizei *length,
3139 GLfloat *params)
3140 {
3141 Context *context = GetValidGlobalContext();
3142 EVENT(context, GLGetSamplerParameterfvRobustANGLE,
3143 "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3144 ", params = 0x%016" PRIxPTR "",
3145 CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
3146 (uintptr_t)length, (uintptr_t)params);
3147
3148 if (context)
3149 {
3150 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
3151 SCOPED_SHARE_CONTEXT_LOCK(context);
3152 bool isCallValid = (context->skipValidation() ||
3153 ValidateGetSamplerParameterfvRobustANGLE(
3154 context, angle::EntryPoint::GLGetSamplerParameterfvRobustANGLE,
3155 samplerPacked, pname, bufSize, length, params));
3156 if (isCallValid)
3157 {
3158 context->getSamplerParameterfvRobust(samplerPacked, pname, bufSize, length, params);
3159 }
3160 ANGLE_CAPTURE_GL(GetSamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked,
3161 pname, bufSize, length, params);
3162 }
3163 else
3164 {
3165 GenerateContextLostErrorOnCurrentGlobalContext();
3166 }
3167 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3168 }
3169
GL_GetFramebufferParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3170 void GL_APIENTRY GL_GetFramebufferParameterivRobustANGLE(GLenum target,
3171 GLenum pname,
3172 GLsizei bufSize,
3173 GLsizei *length,
3174 GLint *params)
3175 {
3176 Context *context = GetValidGlobalContext();
3177 EVENT(context, GLGetFramebufferParameterivRobustANGLE,
3178 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3179 ", params = 0x%016" PRIxPTR "",
3180 CID(context), GLenumToString(GLESEnum::AllEnums, target),
3181 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
3182
3183 if (context)
3184 {
3185 SCOPED_SHARE_CONTEXT_LOCK(context);
3186 bool isCallValid = (context->skipValidation() ||
3187 ValidateGetFramebufferParameterivRobustANGLE(
3188 context, angle::EntryPoint::GLGetFramebufferParameterivRobustANGLE,
3189 target, pname, bufSize, length, params));
3190 if (isCallValid)
3191 {
3192 context->getFramebufferParameterivRobust(target, pname, bufSize, length, params);
3193 }
3194 ANGLE_CAPTURE_GL(GetFramebufferParameterivRobustANGLE, isCallValid, context, target, pname,
3195 bufSize, length, params);
3196 }
3197 else
3198 {
3199 GenerateContextLostErrorOnCurrentGlobalContext();
3200 }
3201 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3202 }
3203
GL_GetProgramInterfaceivRobustANGLE(GLuint program,GLenum programInterface,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3204 void GL_APIENTRY GL_GetProgramInterfaceivRobustANGLE(GLuint program,
3205 GLenum programInterface,
3206 GLenum pname,
3207 GLsizei bufSize,
3208 GLsizei *length,
3209 GLint *params)
3210 {
3211 Context *context = GetValidGlobalContext();
3212 EVENT(context, GLGetProgramInterfaceivRobustANGLE,
3213 "context = %d, program = %u, programInterface = %s, pname = %s, bufSize = %d, length = "
3214 "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
3215 CID(context), program, GLenumToString(GLESEnum::AllEnums, programInterface),
3216 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
3217
3218 if (context)
3219 {
3220 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
3221 SCOPED_SHARE_CONTEXT_LOCK(context);
3222 bool isCallValid = (context->skipValidation() ||
3223 ValidateGetProgramInterfaceivRobustANGLE(
3224 context, angle::EntryPoint::GLGetProgramInterfaceivRobustANGLE,
3225 programPacked, programInterface, pname, bufSize, length, params));
3226 if (isCallValid)
3227 {
3228 context->getProgramInterfaceivRobust(programPacked, programInterface, pname, bufSize,
3229 length, params);
3230 }
3231 ANGLE_CAPTURE_GL(GetProgramInterfaceivRobustANGLE, isCallValid, context, programPacked,
3232 programInterface, pname, bufSize, length, params);
3233 }
3234 else
3235 {
3236 GenerateContextLostErrorOnCurrentGlobalContext();
3237 }
3238 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3239 }
3240
GL_GetBooleani_vRobustANGLE(GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLboolean * data)3241 void GL_APIENTRY GL_GetBooleani_vRobustANGLE(GLenum target,
3242 GLuint index,
3243 GLsizei bufSize,
3244 GLsizei *length,
3245 GLboolean *data)
3246 {
3247 Context *context = GetValidGlobalContext();
3248 EVENT(context, GLGetBooleani_vRobustANGLE,
3249 "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
3250 ", data = 0x%016" PRIxPTR "",
3251 CID(context), GLenumToString(GLESEnum::AllEnums, target), index, bufSize,
3252 (uintptr_t)length, (uintptr_t)data);
3253
3254 if (context)
3255 {
3256 SCOPED_SHARE_CONTEXT_LOCK(context);
3257 bool isCallValid = (context->skipValidation() ||
3258 ValidateGetBooleani_vRobustANGLE(
3259 context, angle::EntryPoint::GLGetBooleani_vRobustANGLE, target,
3260 index, bufSize, length, data));
3261 if (isCallValid)
3262 {
3263 context->getBooleani_vRobust(target, index, bufSize, length, data);
3264 }
3265 ANGLE_CAPTURE_GL(GetBooleani_vRobustANGLE, isCallValid, context, target, index, bufSize,
3266 length, data);
3267 }
3268 else
3269 {
3270 GenerateContextLostErrorOnCurrentGlobalContext();
3271 }
3272 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3273 }
3274
GL_GetMultisamplefvRobustANGLE(GLenum pname,GLuint index,GLsizei bufSize,GLsizei * length,GLfloat * val)3275 void GL_APIENTRY GL_GetMultisamplefvRobustANGLE(GLenum pname,
3276 GLuint index,
3277 GLsizei bufSize,
3278 GLsizei *length,
3279 GLfloat *val)
3280 {
3281 Context *context = GetValidGlobalContext();
3282 EVENT(context, GLGetMultisamplefvRobustANGLE,
3283 "context = %d, pname = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
3284 ", val = 0x%016" PRIxPTR "",
3285 CID(context), GLenumToString(GLESEnum::AllEnums, pname), index, bufSize,
3286 (uintptr_t)length, (uintptr_t)val);
3287
3288 if (context)
3289 {
3290 SCOPED_SHARE_CONTEXT_LOCK(context);
3291 bool isCallValid = (context->skipValidation() ||
3292 ValidateGetMultisamplefvRobustANGLE(
3293 context, angle::EntryPoint::GLGetMultisamplefvRobustANGLE, pname,
3294 index, bufSize, length, val));
3295 if (isCallValid)
3296 {
3297 context->getMultisamplefvRobust(pname, index, bufSize, length, val);
3298 }
3299 ANGLE_CAPTURE_GL(GetMultisamplefvRobustANGLE, isCallValid, context, pname, index, bufSize,
3300 length, val);
3301 }
3302 else
3303 {
3304 GenerateContextLostErrorOnCurrentGlobalContext();
3305 }
3306 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3307 }
3308
GL_GetTexLevelParameterivRobustANGLE(GLenum target,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3309 void GL_APIENTRY GL_GetTexLevelParameterivRobustANGLE(GLenum target,
3310 GLint level,
3311 GLenum pname,
3312 GLsizei bufSize,
3313 GLsizei *length,
3314 GLint *params)
3315 {
3316 Context *context = GetValidGlobalContext();
3317 EVENT(context, GLGetTexLevelParameterivRobustANGLE,
3318 "context = %d, target = %s, level = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3319 ", params = 0x%016" PRIxPTR "",
3320 CID(context), GLenumToString(GLESEnum::AllEnums, target), level,
3321 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
3322
3323 if (context)
3324 {
3325 TextureTarget targetPacked = PackParam<TextureTarget>(target);
3326 SCOPED_SHARE_CONTEXT_LOCK(context);
3327 bool isCallValid = (context->skipValidation() ||
3328 ValidateGetTexLevelParameterivRobustANGLE(
3329 context, angle::EntryPoint::GLGetTexLevelParameterivRobustANGLE,
3330 targetPacked, level, pname, bufSize, length, params));
3331 if (isCallValid)
3332 {
3333 context->getTexLevelParameterivRobust(targetPacked, level, pname, bufSize, length,
3334 params);
3335 }
3336 ANGLE_CAPTURE_GL(GetTexLevelParameterivRobustANGLE, isCallValid, context, targetPacked,
3337 level, pname, bufSize, length, params);
3338 }
3339 else
3340 {
3341 GenerateContextLostErrorOnCurrentGlobalContext();
3342 }
3343 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3344 }
3345
GL_GetTexLevelParameterfvRobustANGLE(GLenum target,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)3346 void GL_APIENTRY GL_GetTexLevelParameterfvRobustANGLE(GLenum target,
3347 GLint level,
3348 GLenum pname,
3349 GLsizei bufSize,
3350 GLsizei *length,
3351 GLfloat *params)
3352 {
3353 Context *context = GetValidGlobalContext();
3354 EVENT(context, GLGetTexLevelParameterfvRobustANGLE,
3355 "context = %d, target = %s, level = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3356 ", params = 0x%016" PRIxPTR "",
3357 CID(context), GLenumToString(GLESEnum::AllEnums, target), level,
3358 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
3359
3360 if (context)
3361 {
3362 TextureTarget targetPacked = PackParam<TextureTarget>(target);
3363 SCOPED_SHARE_CONTEXT_LOCK(context);
3364 bool isCallValid = (context->skipValidation() ||
3365 ValidateGetTexLevelParameterfvRobustANGLE(
3366 context, angle::EntryPoint::GLGetTexLevelParameterfvRobustANGLE,
3367 targetPacked, level, pname, bufSize, length, params));
3368 if (isCallValid)
3369 {
3370 context->getTexLevelParameterfvRobust(targetPacked, level, pname, bufSize, length,
3371 params);
3372 }
3373 ANGLE_CAPTURE_GL(GetTexLevelParameterfvRobustANGLE, isCallValid, context, targetPacked,
3374 level, pname, bufSize, length, params);
3375 }
3376 else
3377 {
3378 GenerateContextLostErrorOnCurrentGlobalContext();
3379 }
3380 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3381 }
3382
GL_GetPointervRobustANGLERobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)3383 void GL_APIENTRY GL_GetPointervRobustANGLERobustANGLE(GLenum pname,
3384 GLsizei bufSize,
3385 GLsizei *length,
3386 void **params)
3387 {
3388 Context *context = GetValidGlobalContext();
3389 EVENT(context, GLGetPointervRobustANGLERobustANGLE,
3390 "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3391 ", params = 0x%016" PRIxPTR "",
3392 CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length,
3393 (uintptr_t)params);
3394
3395 if (context)
3396 {
3397 SCOPED_SHARE_CONTEXT_LOCK(context);
3398 bool isCallValid = (context->skipValidation() ||
3399 ValidateGetPointervRobustANGLERobustANGLE(
3400 context, angle::EntryPoint::GLGetPointervRobustANGLERobustANGLE,
3401 pname, bufSize, length, params));
3402 if (isCallValid)
3403 {
3404 context->getPointervRobustANGLERobust(pname, bufSize, length, params);
3405 }
3406 ANGLE_CAPTURE_GL(GetPointervRobustANGLERobustANGLE, isCallValid, context, pname, bufSize,
3407 length, params);
3408 }
3409 else
3410 {
3411 GenerateContextLostErrorOnCurrentGlobalContext();
3412 }
3413 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3414 }
3415
GL_ReadnPixelsRobustANGLE(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLsizei * length,GLsizei * columns,GLsizei * rows,void * data)3416 void GL_APIENTRY GL_ReadnPixelsRobustANGLE(GLint x,
3417 GLint y,
3418 GLsizei width,
3419 GLsizei height,
3420 GLenum format,
3421 GLenum type,
3422 GLsizei bufSize,
3423 GLsizei *length,
3424 GLsizei *columns,
3425 GLsizei *rows,
3426 void *data)
3427 {
3428 Context *context = GetValidGlobalContext();
3429 EVENT(context, GLReadnPixelsRobustANGLE,
3430 "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize "
3431 "= %d, length = 0x%016" PRIxPTR ", columns = 0x%016" PRIxPTR ", rows = 0x%016" PRIxPTR
3432 ", data = 0x%016" PRIxPTR "",
3433 CID(context), x, y, width, height, GLenumToString(GLESEnum::AllEnums, format),
3434 GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)length, (uintptr_t)columns,
3435 (uintptr_t)rows, (uintptr_t)data);
3436
3437 if (context)
3438 {
3439 SCOPED_SHARE_CONTEXT_LOCK(context);
3440 bool isCallValid =
3441 (context->skipValidation() ||
3442 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
3443 context->getMutableErrorSetForValidation(),
3444 angle::EntryPoint::GLReadnPixelsRobustANGLE) &&
3445 ValidateReadnPixelsRobustANGLE(context, angle::EntryPoint::GLReadnPixelsRobustANGLE,
3446 x, y, width, height, format, type, bufSize, length,
3447 columns, rows, data)));
3448 if (isCallValid)
3449 {
3450 context->readnPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
3451 rows, data);
3452 }
3453 ANGLE_CAPTURE_GL(ReadnPixelsRobustANGLE, isCallValid, context, x, y, width, height, format,
3454 type, bufSize, length, columns, rows, data);
3455 }
3456 else
3457 {
3458 GenerateContextLostErrorOnCurrentGlobalContext();
3459 }
3460 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3461 }
3462
GL_GetnUniformfvRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLfloat * params)3463 void GL_APIENTRY GL_GetnUniformfvRobustANGLE(GLuint program,
3464 GLint location,
3465 GLsizei bufSize,
3466 GLsizei *length,
3467 GLfloat *params)
3468 {
3469 Context *context = GetValidGlobalContext();
3470 EVENT(context, GLGetnUniformfvRobustANGLE,
3471 "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
3472 ", params = 0x%016" PRIxPTR "",
3473 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
3474
3475 if (context)
3476 {
3477 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
3478 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3479 SCOPED_SHARE_CONTEXT_LOCK(context);
3480 bool isCallValid = (context->skipValidation() ||
3481 ValidateGetnUniformfvRobustANGLE(
3482 context, angle::EntryPoint::GLGetnUniformfvRobustANGLE,
3483 programPacked, locationPacked, bufSize, length, params));
3484 if (isCallValid)
3485 {
3486 context->getnUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
3487 }
3488 ANGLE_CAPTURE_GL(GetnUniformfvRobustANGLE, isCallValid, context, programPacked,
3489 locationPacked, bufSize, length, params);
3490 }
3491 else
3492 {
3493 GenerateContextLostErrorOnCurrentGlobalContext();
3494 }
3495 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3496 }
3497
GL_GetnUniformivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLint * params)3498 void GL_APIENTRY GL_GetnUniformivRobustANGLE(GLuint program,
3499 GLint location,
3500 GLsizei bufSize,
3501 GLsizei *length,
3502 GLint *params)
3503 {
3504 Context *context = GetValidGlobalContext();
3505 EVENT(context, GLGetnUniformivRobustANGLE,
3506 "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
3507 ", params = 0x%016" PRIxPTR "",
3508 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
3509
3510 if (context)
3511 {
3512 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
3513 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3514 SCOPED_SHARE_CONTEXT_LOCK(context);
3515 bool isCallValid = (context->skipValidation() ||
3516 ValidateGetnUniformivRobustANGLE(
3517 context, angle::EntryPoint::GLGetnUniformivRobustANGLE,
3518 programPacked, locationPacked, bufSize, length, params));
3519 if (isCallValid)
3520 {
3521 context->getnUniformivRobust(programPacked, locationPacked, bufSize, length, params);
3522 }
3523 ANGLE_CAPTURE_GL(GetnUniformivRobustANGLE, isCallValid, context, programPacked,
3524 locationPacked, bufSize, length, params);
3525 }
3526 else
3527 {
3528 GenerateContextLostErrorOnCurrentGlobalContext();
3529 }
3530 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3531 }
3532
GL_GetnUniformuivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLuint * params)3533 void GL_APIENTRY GL_GetnUniformuivRobustANGLE(GLuint program,
3534 GLint location,
3535 GLsizei bufSize,
3536 GLsizei *length,
3537 GLuint *params)
3538 {
3539 Context *context = GetValidGlobalContext();
3540 EVENT(context, GLGetnUniformuivRobustANGLE,
3541 "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR
3542 ", params = 0x%016" PRIxPTR "",
3543 CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
3544
3545 if (context)
3546 {
3547 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
3548 UniformLocation locationPacked = PackParam<UniformLocation>(location);
3549 SCOPED_SHARE_CONTEXT_LOCK(context);
3550 bool isCallValid = (context->skipValidation() ||
3551 ValidateGetnUniformuivRobustANGLE(
3552 context, angle::EntryPoint::GLGetnUniformuivRobustANGLE,
3553 programPacked, locationPacked, bufSize, length, params));
3554 if (isCallValid)
3555 {
3556 context->getnUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
3557 }
3558 ANGLE_CAPTURE_GL(GetnUniformuivRobustANGLE, isCallValid, context, programPacked,
3559 locationPacked, bufSize, length, params);
3560 }
3561 else
3562 {
3563 GenerateContextLostErrorOnCurrentGlobalContext();
3564 }
3565 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3566 }
3567
GL_TexParameterIivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLint * params)3568 void GL_APIENTRY GL_TexParameterIivRobustANGLE(GLenum target,
3569 GLenum pname,
3570 GLsizei bufSize,
3571 const GLint *params)
3572 {
3573 Context *context = GetValidGlobalContext();
3574 EVENT(context, GLTexParameterIivRobustANGLE,
3575 "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "",
3576 CID(context), GLenumToString(GLESEnum::AllEnums, target),
3577 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)params);
3578
3579 if (context)
3580 {
3581 TextureType targetPacked = PackParam<TextureType>(target);
3582 SCOPED_SHARE_CONTEXT_LOCK(context);
3583 bool isCallValid = (context->skipValidation() ||
3584 ValidateTexParameterIivRobustANGLE(
3585 context, angle::EntryPoint::GLTexParameterIivRobustANGLE,
3586 targetPacked, pname, bufSize, params));
3587 if (isCallValid)
3588 {
3589 context->texParameterIivRobust(targetPacked, pname, bufSize, params);
3590 }
3591 ANGLE_CAPTURE_GL(TexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname,
3592 bufSize, params);
3593 }
3594 else
3595 {
3596 GenerateContextLostErrorOnCurrentGlobalContext();
3597 }
3598 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3599 }
3600
GL_TexParameterIuivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLuint * params)3601 void GL_APIENTRY GL_TexParameterIuivRobustANGLE(GLenum target,
3602 GLenum pname,
3603 GLsizei bufSize,
3604 const GLuint *params)
3605 {
3606 Context *context = GetValidGlobalContext();
3607 EVENT(context, GLTexParameterIuivRobustANGLE,
3608 "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "",
3609 CID(context), GLenumToString(GLESEnum::AllEnums, target),
3610 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)params);
3611
3612 if (context)
3613 {
3614 TextureType targetPacked = PackParam<TextureType>(target);
3615 SCOPED_SHARE_CONTEXT_LOCK(context);
3616 bool isCallValid = (context->skipValidation() ||
3617 ValidateTexParameterIuivRobustANGLE(
3618 context, angle::EntryPoint::GLTexParameterIuivRobustANGLE,
3619 targetPacked, pname, bufSize, params));
3620 if (isCallValid)
3621 {
3622 context->texParameterIuivRobust(targetPacked, pname, bufSize, params);
3623 }
3624 ANGLE_CAPTURE_GL(TexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname,
3625 bufSize, params);
3626 }
3627 else
3628 {
3629 GenerateContextLostErrorOnCurrentGlobalContext();
3630 }
3631 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3632 }
3633
GL_GetTexParameterIivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3634 void GL_APIENTRY GL_GetTexParameterIivRobustANGLE(GLenum target,
3635 GLenum pname,
3636 GLsizei bufSize,
3637 GLsizei *length,
3638 GLint *params)
3639 {
3640 Context *context = GetValidGlobalContext();
3641 EVENT(context, GLGetTexParameterIivRobustANGLE,
3642 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3643 ", params = 0x%016" PRIxPTR "",
3644 CID(context), GLenumToString(GLESEnum::AllEnums, target),
3645 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
3646
3647 if (context)
3648 {
3649 TextureType targetPacked = PackParam<TextureType>(target);
3650 SCOPED_SHARE_CONTEXT_LOCK(context);
3651 bool isCallValid = (context->skipValidation() ||
3652 ValidateGetTexParameterIivRobustANGLE(
3653 context, angle::EntryPoint::GLGetTexParameterIivRobustANGLE,
3654 targetPacked, pname, bufSize, length, params));
3655 if (isCallValid)
3656 {
3657 context->getTexParameterIivRobust(targetPacked, pname, bufSize, length, params);
3658 }
3659 ANGLE_CAPTURE_GL(GetTexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname,
3660 bufSize, length, params);
3661 }
3662 else
3663 {
3664 GenerateContextLostErrorOnCurrentGlobalContext();
3665 }
3666 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3667 }
3668
GL_GetTexParameterIuivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)3669 void GL_APIENTRY GL_GetTexParameterIuivRobustANGLE(GLenum target,
3670 GLenum pname,
3671 GLsizei bufSize,
3672 GLsizei *length,
3673 GLuint *params)
3674 {
3675 Context *context = GetValidGlobalContext();
3676 EVENT(context, GLGetTexParameterIuivRobustANGLE,
3677 "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3678 ", params = 0x%016" PRIxPTR "",
3679 CID(context), GLenumToString(GLESEnum::AllEnums, target),
3680 GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params);
3681
3682 if (context)
3683 {
3684 TextureType targetPacked = PackParam<TextureType>(target);
3685 SCOPED_SHARE_CONTEXT_LOCK(context);
3686 bool isCallValid = (context->skipValidation() ||
3687 ValidateGetTexParameterIuivRobustANGLE(
3688 context, angle::EntryPoint::GLGetTexParameterIuivRobustANGLE,
3689 targetPacked, pname, bufSize, length, params));
3690 if (isCallValid)
3691 {
3692 context->getTexParameterIuivRobust(targetPacked, pname, bufSize, length, params);
3693 }
3694 ANGLE_CAPTURE_GL(GetTexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname,
3695 bufSize, length, params);
3696 }
3697 else
3698 {
3699 GenerateContextLostErrorOnCurrentGlobalContext();
3700 }
3701 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3702 }
3703
GL_SamplerParameterIivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLint * param)3704 void GL_APIENTRY GL_SamplerParameterIivRobustANGLE(GLuint sampler,
3705 GLenum pname,
3706 GLsizei bufSize,
3707 const GLint *param)
3708 {
3709 Context *context = GetValidGlobalContext();
3710 EVENT(context, GLSamplerParameterIivRobustANGLE,
3711 "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "",
3712 CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
3713 (uintptr_t)param);
3714
3715 if (context)
3716 {
3717 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
3718 SCOPED_SHARE_CONTEXT_LOCK(context);
3719 bool isCallValid = (context->skipValidation() ||
3720 ValidateSamplerParameterIivRobustANGLE(
3721 context, angle::EntryPoint::GLSamplerParameterIivRobustANGLE,
3722 samplerPacked, pname, bufSize, param));
3723 if (isCallValid)
3724 {
3725 context->samplerParameterIivRobust(samplerPacked, pname, bufSize, param);
3726 }
3727 ANGLE_CAPTURE_GL(SamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, pname,
3728 bufSize, param);
3729 }
3730 else
3731 {
3732 GenerateContextLostErrorOnCurrentGlobalContext();
3733 }
3734 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3735 }
3736
GL_SamplerParameterIuivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLuint * param)3737 void GL_APIENTRY GL_SamplerParameterIuivRobustANGLE(GLuint sampler,
3738 GLenum pname,
3739 GLsizei bufSize,
3740 const GLuint *param)
3741 {
3742 Context *context = GetValidGlobalContext();
3743 EVENT(context, GLSamplerParameterIuivRobustANGLE,
3744 "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "",
3745 CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
3746 (uintptr_t)param);
3747
3748 if (context)
3749 {
3750 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
3751 SCOPED_SHARE_CONTEXT_LOCK(context);
3752 bool isCallValid = (context->skipValidation() ||
3753 ValidateSamplerParameterIuivRobustANGLE(
3754 context, angle::EntryPoint::GLSamplerParameterIuivRobustANGLE,
3755 samplerPacked, pname, bufSize, param));
3756 if (isCallValid)
3757 {
3758 context->samplerParameterIuivRobust(samplerPacked, pname, bufSize, param);
3759 }
3760 ANGLE_CAPTURE_GL(SamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked,
3761 pname, bufSize, param);
3762 }
3763 else
3764 {
3765 GenerateContextLostErrorOnCurrentGlobalContext();
3766 }
3767 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3768 }
3769
GL_GetSamplerParameterIivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3770 void GL_APIENTRY GL_GetSamplerParameterIivRobustANGLE(GLuint sampler,
3771 GLenum pname,
3772 GLsizei bufSize,
3773 GLsizei *length,
3774 GLint *params)
3775 {
3776 Context *context = GetValidGlobalContext();
3777 EVENT(context, GLGetSamplerParameterIivRobustANGLE,
3778 "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3779 ", params = 0x%016" PRIxPTR "",
3780 CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
3781 (uintptr_t)length, (uintptr_t)params);
3782
3783 if (context)
3784 {
3785 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
3786 SCOPED_SHARE_CONTEXT_LOCK(context);
3787 bool isCallValid = (context->skipValidation() ||
3788 ValidateGetSamplerParameterIivRobustANGLE(
3789 context, angle::EntryPoint::GLGetSamplerParameterIivRobustANGLE,
3790 samplerPacked, pname, bufSize, length, params));
3791 if (isCallValid)
3792 {
3793 context->getSamplerParameterIivRobust(samplerPacked, pname, bufSize, length, params);
3794 }
3795 ANGLE_CAPTURE_GL(GetSamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked,
3796 pname, bufSize, length, params);
3797 }
3798 else
3799 {
3800 GenerateContextLostErrorOnCurrentGlobalContext();
3801 }
3802 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3803 }
3804
GL_GetSamplerParameterIuivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)3805 void GL_APIENTRY GL_GetSamplerParameterIuivRobustANGLE(GLuint sampler,
3806 GLenum pname,
3807 GLsizei bufSize,
3808 GLsizei *length,
3809 GLuint *params)
3810 {
3811 Context *context = GetValidGlobalContext();
3812 EVENT(context, GLGetSamplerParameterIuivRobustANGLE,
3813 "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3814 ", params = 0x%016" PRIxPTR "",
3815 CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize,
3816 (uintptr_t)length, (uintptr_t)params);
3817
3818 if (context)
3819 {
3820 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
3821 SCOPED_SHARE_CONTEXT_LOCK(context);
3822 bool isCallValid = (context->skipValidation() ||
3823 ValidateGetSamplerParameterIuivRobustANGLE(
3824 context, angle::EntryPoint::GLGetSamplerParameterIuivRobustANGLE,
3825 samplerPacked, pname, bufSize, length, params));
3826 if (isCallValid)
3827 {
3828 context->getSamplerParameterIuivRobust(samplerPacked, pname, bufSize, length, params);
3829 }
3830 ANGLE_CAPTURE_GL(GetSamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked,
3831 pname, bufSize, length, params);
3832 }
3833 else
3834 {
3835 GenerateContextLostErrorOnCurrentGlobalContext();
3836 }
3837 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3838 }
3839
GL_GetQueryObjectivRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3840 void GL_APIENTRY GL_GetQueryObjectivRobustANGLE(GLuint id,
3841 GLenum pname,
3842 GLsizei bufSize,
3843 GLsizei *length,
3844 GLint *params)
3845 {
3846 Context *context = GetGlobalContext();
3847 EVENT(context, GLGetQueryObjectivRobustANGLE,
3848 "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3849 ", params = 0x%016" PRIxPTR "",
3850 CID(context), id, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length,
3851 (uintptr_t)params);
3852
3853 if (context)
3854 {
3855 QueryID idPacked = PackParam<QueryID>(id);
3856 SCOPED_SHARE_CONTEXT_LOCK(context);
3857 bool isCallValid = (context->skipValidation() ||
3858 ValidateGetQueryObjectivRobustANGLE(
3859 context, angle::EntryPoint::GLGetQueryObjectivRobustANGLE, idPacked,
3860 pname, bufSize, length, params));
3861 if (isCallValid)
3862 {
3863 context->getQueryObjectivRobust(idPacked, pname, bufSize, length, params);
3864 }
3865 ANGLE_CAPTURE_GL(GetQueryObjectivRobustANGLE, isCallValid, context, idPacked, pname,
3866 bufSize, length, params);
3867 }
3868 else
3869 {
3870 }
3871 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3872 }
3873
GL_GetQueryObjecti64vRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)3874 void GL_APIENTRY GL_GetQueryObjecti64vRobustANGLE(GLuint id,
3875 GLenum pname,
3876 GLsizei bufSize,
3877 GLsizei *length,
3878 GLint64 *params)
3879 {
3880 Context *context = GetGlobalContext();
3881 EVENT(context, GLGetQueryObjecti64vRobustANGLE,
3882 "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3883 ", params = 0x%016" PRIxPTR "",
3884 CID(context), id, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length,
3885 (uintptr_t)params);
3886
3887 if (context)
3888 {
3889 QueryID idPacked = PackParam<QueryID>(id);
3890 SCOPED_SHARE_CONTEXT_LOCK(context);
3891 bool isCallValid = (context->skipValidation() ||
3892 ValidateGetQueryObjecti64vRobustANGLE(
3893 context, angle::EntryPoint::GLGetQueryObjecti64vRobustANGLE,
3894 idPacked, pname, bufSize, length, params));
3895 if (isCallValid)
3896 {
3897 context->getQueryObjecti64vRobust(idPacked, pname, bufSize, length, params);
3898 }
3899 ANGLE_CAPTURE_GL(GetQueryObjecti64vRobustANGLE, isCallValid, context, idPacked, pname,
3900 bufSize, length, params);
3901 }
3902 else
3903 {
3904 }
3905 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3906 }
3907
GL_GetQueryObjectui64vRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint64 * params)3908 void GL_APIENTRY GL_GetQueryObjectui64vRobustANGLE(GLuint id,
3909 GLenum pname,
3910 GLsizei bufSize,
3911 GLsizei *length,
3912 GLuint64 *params)
3913 {
3914 Context *context = GetValidGlobalContext();
3915 EVENT(context, GLGetQueryObjectui64vRobustANGLE,
3916 "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
3917 ", params = 0x%016" PRIxPTR "",
3918 CID(context), id, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length,
3919 (uintptr_t)params);
3920
3921 if (context)
3922 {
3923 QueryID idPacked = PackParam<QueryID>(id);
3924 SCOPED_SHARE_CONTEXT_LOCK(context);
3925 bool isCallValid = (context->skipValidation() ||
3926 ValidateGetQueryObjectui64vRobustANGLE(
3927 context, angle::EntryPoint::GLGetQueryObjectui64vRobustANGLE,
3928 idPacked, pname, bufSize, length, params));
3929 if (isCallValid)
3930 {
3931 context->getQueryObjectui64vRobust(idPacked, pname, bufSize, length, params);
3932 }
3933 ANGLE_CAPTURE_GL(GetQueryObjectui64vRobustANGLE, isCallValid, context, idPacked, pname,
3934 bufSize, length, params);
3935 }
3936 else
3937 {
3938 GenerateContextLostErrorOnCurrentGlobalContext();
3939 }
3940 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3941 }
3942
3943 // GL_ANGLE_robust_fragment_shader_output
3944
3945 // GL_ANGLE_robust_resource_initialization
3946
3947 // GL_ANGLE_semaphore_fuchsia
GL_ImportSemaphoreZirconHandleANGLE(GLuint semaphore,GLenum handleType,GLuint handle)3948 void GL_APIENTRY GL_ImportSemaphoreZirconHandleANGLE(GLuint semaphore,
3949 GLenum handleType,
3950 GLuint handle)
3951 {
3952 Context *context = GetValidGlobalContext();
3953 EVENT(context, GLImportSemaphoreZirconHandleANGLE,
3954 "context = %d, semaphore = %u, handleType = %s, handle = %u", CID(context), semaphore,
3955 GLenumToString(GLESEnum::ExternalHandleType, handleType), handle);
3956
3957 if (context)
3958 {
3959 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
3960 HandleType handleTypePacked = PackParam<HandleType>(handleType);
3961 SCOPED_SHARE_CONTEXT_LOCK(context);
3962 bool isCallValid =
3963 (context->skipValidation() ||
3964 (ValidatePixelLocalStorageInactive(
3965 context->getPrivateState(), context->getMutableErrorSetForValidation(),
3966 angle::EntryPoint::GLImportSemaphoreZirconHandleANGLE) &&
3967 ValidateImportSemaphoreZirconHandleANGLE(
3968 context, angle::EntryPoint::GLImportSemaphoreZirconHandleANGLE, semaphorePacked,
3969 handleTypePacked, handle)));
3970 if (isCallValid)
3971 {
3972 context->importSemaphoreZirconHandle(semaphorePacked, handleTypePacked, handle);
3973 }
3974 ANGLE_CAPTURE_GL(ImportSemaphoreZirconHandleANGLE, isCallValid, context, semaphorePacked,
3975 handleTypePacked, handle);
3976 }
3977 else
3978 {
3979 GenerateContextLostErrorOnCurrentGlobalContext();
3980 }
3981 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
3982 }
3983
3984 // GL_ANGLE_shader_binary
3985
3986 // GL_ANGLE_shader_pixel_local_storage
GL_FramebufferMemorylessPixelLocalStorageANGLE(GLint plane,GLenum internalformat)3987 void GL_APIENTRY GL_FramebufferMemorylessPixelLocalStorageANGLE(GLint plane, GLenum internalformat)
3988 {
3989 Context *context = GetValidGlobalContext();
3990 EVENT(context, GLFramebufferMemorylessPixelLocalStorageANGLE,
3991 "context = %d, plane = %d, internalformat = %s", CID(context), plane,
3992 GLenumToString(GLESEnum::AllEnums, internalformat));
3993
3994 if (context)
3995 {
3996 SCOPED_SHARE_CONTEXT_LOCK(context);
3997 bool isCallValid =
3998 (context->skipValidation() ||
3999 (ValidatePixelLocalStorageInactive(
4000 context->getPrivateState(), context->getMutableErrorSetForValidation(),
4001 angle::EntryPoint::GLFramebufferMemorylessPixelLocalStorageANGLE) &&
4002 ValidateFramebufferMemorylessPixelLocalStorageANGLE(
4003 context, angle::EntryPoint::GLFramebufferMemorylessPixelLocalStorageANGLE, plane,
4004 internalformat)));
4005 if (isCallValid)
4006 {
4007 context->framebufferMemorylessPixelLocalStorage(plane, internalformat);
4008 }
4009 ANGLE_CAPTURE_GL(FramebufferMemorylessPixelLocalStorageANGLE, isCallValid, context, plane,
4010 internalformat);
4011 }
4012 else
4013 {
4014 GenerateContextLostErrorOnCurrentGlobalContext();
4015 }
4016 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4017 }
4018
GL_FramebufferTexturePixelLocalStorageANGLE(GLint plane,GLuint backingtexture,GLint level,GLint layer)4019 void GL_APIENTRY GL_FramebufferTexturePixelLocalStorageANGLE(GLint plane,
4020 GLuint backingtexture,
4021 GLint level,
4022 GLint layer)
4023 {
4024 Context *context = GetValidGlobalContext();
4025 EVENT(context, GLFramebufferTexturePixelLocalStorageANGLE,
4026 "context = %d, plane = %d, backingtexture = %u, level = %d, layer = %d", CID(context),
4027 plane, backingtexture, level, layer);
4028
4029 if (context)
4030 {
4031 TextureID backingtexturePacked = PackParam<TextureID>(backingtexture);
4032 SCOPED_SHARE_CONTEXT_LOCK(context);
4033 bool isCallValid =
4034 (context->skipValidation() ||
4035 (ValidatePixelLocalStorageInactive(
4036 context->getPrivateState(), context->getMutableErrorSetForValidation(),
4037 angle::EntryPoint::GLFramebufferTexturePixelLocalStorageANGLE) &&
4038 ValidateFramebufferTexturePixelLocalStorageANGLE(
4039 context, angle::EntryPoint::GLFramebufferTexturePixelLocalStorageANGLE, plane,
4040 backingtexturePacked, level, layer)));
4041 if (isCallValid)
4042 {
4043 context->framebufferTexturePixelLocalStorage(plane, backingtexturePacked, level, layer);
4044 }
4045 ANGLE_CAPTURE_GL(FramebufferTexturePixelLocalStorageANGLE, isCallValid, context, plane,
4046 backingtexturePacked, level, layer);
4047 }
4048 else
4049 {
4050 GenerateContextLostErrorOnCurrentGlobalContext();
4051 }
4052 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4053 }
4054
GL_FramebufferPixelLocalClearValuefvANGLE(GLint plane,const GLfloat * value)4055 void GL_APIENTRY GL_FramebufferPixelLocalClearValuefvANGLE(GLint plane, const GLfloat *value)
4056 {
4057 Context *context = GetValidGlobalContext();
4058 EVENT(context, GLFramebufferPixelLocalClearValuefvANGLE,
4059 "context = %d, plane = %d, value = 0x%016" PRIxPTR "", CID(context), plane,
4060 (uintptr_t)value);
4061
4062 if (context)
4063 {
4064 SCOPED_SHARE_CONTEXT_LOCK(context);
4065 bool isCallValid =
4066 (context->skipValidation() ||
4067 (ValidatePixelLocalStorageInactive(
4068 context->getPrivateState(), context->getMutableErrorSetForValidation(),
4069 angle::EntryPoint::GLFramebufferPixelLocalClearValuefvANGLE) &&
4070 ValidateFramebufferPixelLocalClearValuefvANGLE(
4071 context, angle::EntryPoint::GLFramebufferPixelLocalClearValuefvANGLE, plane,
4072 value)));
4073 if (isCallValid)
4074 {
4075 context->framebufferPixelLocalClearValuefv(plane, value);
4076 }
4077 ANGLE_CAPTURE_GL(FramebufferPixelLocalClearValuefvANGLE, isCallValid, context, plane,
4078 value);
4079 }
4080 else
4081 {
4082 GenerateContextLostErrorOnCurrentGlobalContext();
4083 }
4084 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4085 }
4086
GL_FramebufferPixelLocalClearValueivANGLE(GLint plane,const GLint * value)4087 void GL_APIENTRY GL_FramebufferPixelLocalClearValueivANGLE(GLint plane, const GLint *value)
4088 {
4089 Context *context = GetValidGlobalContext();
4090 EVENT(context, GLFramebufferPixelLocalClearValueivANGLE,
4091 "context = %d, plane = %d, value = 0x%016" PRIxPTR "", CID(context), plane,
4092 (uintptr_t)value);
4093
4094 if (context)
4095 {
4096 SCOPED_SHARE_CONTEXT_LOCK(context);
4097 bool isCallValid =
4098 (context->skipValidation() ||
4099 (ValidatePixelLocalStorageInactive(
4100 context->getPrivateState(), context->getMutableErrorSetForValidation(),
4101 angle::EntryPoint::GLFramebufferPixelLocalClearValueivANGLE) &&
4102 ValidateFramebufferPixelLocalClearValueivANGLE(
4103 context, angle::EntryPoint::GLFramebufferPixelLocalClearValueivANGLE, plane,
4104 value)));
4105 if (isCallValid)
4106 {
4107 context->framebufferPixelLocalClearValueiv(plane, value);
4108 }
4109 ANGLE_CAPTURE_GL(FramebufferPixelLocalClearValueivANGLE, isCallValid, context, plane,
4110 value);
4111 }
4112 else
4113 {
4114 GenerateContextLostErrorOnCurrentGlobalContext();
4115 }
4116 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4117 }
4118
GL_FramebufferPixelLocalClearValueuivANGLE(GLint plane,const GLuint * value)4119 void GL_APIENTRY GL_FramebufferPixelLocalClearValueuivANGLE(GLint plane, const GLuint *value)
4120 {
4121 Context *context = GetValidGlobalContext();
4122 EVENT(context, GLFramebufferPixelLocalClearValueuivANGLE,
4123 "context = %d, plane = %d, value = 0x%016" PRIxPTR "", CID(context), plane,
4124 (uintptr_t)value);
4125
4126 if (context)
4127 {
4128 SCOPED_SHARE_CONTEXT_LOCK(context);
4129 bool isCallValid =
4130 (context->skipValidation() ||
4131 (ValidatePixelLocalStorageInactive(
4132 context->getPrivateState(), context->getMutableErrorSetForValidation(),
4133 angle::EntryPoint::GLFramebufferPixelLocalClearValueuivANGLE) &&
4134 ValidateFramebufferPixelLocalClearValueuivANGLE(
4135 context, angle::EntryPoint::GLFramebufferPixelLocalClearValueuivANGLE, plane,
4136 value)));
4137 if (isCallValid)
4138 {
4139 context->framebufferPixelLocalClearValueuiv(plane, value);
4140 }
4141 ANGLE_CAPTURE_GL(FramebufferPixelLocalClearValueuivANGLE, isCallValid, context, plane,
4142 value);
4143 }
4144 else
4145 {
4146 GenerateContextLostErrorOnCurrentGlobalContext();
4147 }
4148 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4149 }
4150
GL_BeginPixelLocalStorageANGLE(GLsizei n,const GLenum * loadops)4151 void GL_APIENTRY GL_BeginPixelLocalStorageANGLE(GLsizei n, const GLenum *loadops)
4152 {
4153 Context *context = GetValidGlobalContext();
4154 EVENT(context, GLBeginPixelLocalStorageANGLE,
4155 "context = %d, n = %d, loadops = 0x%016" PRIxPTR "", CID(context), n, (uintptr_t)loadops);
4156
4157 if (context)
4158 {
4159 SCOPED_SHARE_CONTEXT_LOCK(context);
4160 bool isCallValid =
4161 (context->skipValidation() ||
4162 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4163 context->getMutableErrorSetForValidation(),
4164 angle::EntryPoint::GLBeginPixelLocalStorageANGLE) &&
4165 ValidateBeginPixelLocalStorageANGLE(
4166 context, angle::EntryPoint::GLBeginPixelLocalStorageANGLE, n, loadops)));
4167 if (isCallValid)
4168 {
4169 context->beginPixelLocalStorage(n, loadops);
4170 }
4171 ANGLE_CAPTURE_GL(BeginPixelLocalStorageANGLE, isCallValid, context, n, loadops);
4172 }
4173 else
4174 {
4175 GenerateContextLostErrorOnCurrentGlobalContext();
4176 }
4177 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4178 }
4179
GL_EndPixelLocalStorageANGLE(GLsizei n,const GLenum * storeops)4180 void GL_APIENTRY GL_EndPixelLocalStorageANGLE(GLsizei n, const GLenum *storeops)
4181 {
4182 Context *context = GetValidGlobalContext();
4183 EVENT(context, GLEndPixelLocalStorageANGLE,
4184 "context = %d, n = %d, storeops = 0x%016" PRIxPTR "", CID(context), n,
4185 (uintptr_t)storeops);
4186
4187 if (context)
4188 {
4189 SCOPED_SHARE_CONTEXT_LOCK(context);
4190 bool isCallValid =
4191 (context->skipValidation() ||
4192 ValidateEndPixelLocalStorageANGLE(
4193 context, angle::EntryPoint::GLEndPixelLocalStorageANGLE, n, storeops));
4194 if (isCallValid)
4195 {
4196 context->endPixelLocalStorage(n, storeops);
4197 }
4198 ANGLE_CAPTURE_GL(EndPixelLocalStorageANGLE, isCallValid, context, n, storeops);
4199 }
4200 else
4201 {
4202 GenerateContextLostErrorOnCurrentGlobalContext();
4203 }
4204 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4205 }
4206
GL_PixelLocalStorageBarrierANGLE()4207 void GL_APIENTRY GL_PixelLocalStorageBarrierANGLE()
4208 {
4209 Context *context = GetValidGlobalContext();
4210 EVENT(context, GLPixelLocalStorageBarrierANGLE, "context = %d", CID(context));
4211
4212 if (context)
4213 {
4214 SCOPED_SHARE_CONTEXT_LOCK(context);
4215 bool isCallValid = (context->skipValidation() ||
4216 ValidatePixelLocalStorageBarrierANGLE(
4217 context, angle::EntryPoint::GLPixelLocalStorageBarrierANGLE));
4218 if (isCallValid)
4219 {
4220 context->pixelLocalStorageBarrier();
4221 }
4222 ANGLE_CAPTURE_GL(PixelLocalStorageBarrierANGLE, isCallValid, context);
4223 }
4224 else
4225 {
4226 GenerateContextLostErrorOnCurrentGlobalContext();
4227 }
4228 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4229 }
4230
GL_FramebufferPixelLocalStorageInterruptANGLE()4231 void GL_APIENTRY GL_FramebufferPixelLocalStorageInterruptANGLE()
4232 {
4233 Context *context = GetValidGlobalContext();
4234 EVENT(context, GLFramebufferPixelLocalStorageInterruptANGLE, "context = %d", CID(context));
4235
4236 if (context)
4237 {
4238 SCOPED_SHARE_CONTEXT_LOCK(context);
4239 bool isCallValid =
4240 (context->skipValidation() ||
4241 ValidateFramebufferPixelLocalStorageInterruptANGLE(
4242 context, angle::EntryPoint::GLFramebufferPixelLocalStorageInterruptANGLE));
4243 if (isCallValid)
4244 {
4245 context->framebufferPixelLocalStorageInterrupt();
4246 }
4247 ANGLE_CAPTURE_GL(FramebufferPixelLocalStorageInterruptANGLE, isCallValid, context);
4248 }
4249 else
4250 {
4251 GenerateContextLostErrorOnCurrentGlobalContext();
4252 }
4253 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4254 }
4255
GL_FramebufferPixelLocalStorageRestoreANGLE()4256 void GL_APIENTRY GL_FramebufferPixelLocalStorageRestoreANGLE()
4257 {
4258 Context *context = GetValidGlobalContext();
4259 EVENT(context, GLFramebufferPixelLocalStorageRestoreANGLE, "context = %d", CID(context));
4260
4261 if (context)
4262 {
4263 SCOPED_SHARE_CONTEXT_LOCK(context);
4264 bool isCallValid =
4265 (context->skipValidation() ||
4266 (ValidatePixelLocalStorageInactive(
4267 context->getPrivateState(), context->getMutableErrorSetForValidation(),
4268 angle::EntryPoint::GLFramebufferPixelLocalStorageRestoreANGLE) &&
4269 ValidateFramebufferPixelLocalStorageRestoreANGLE(
4270 context, angle::EntryPoint::GLFramebufferPixelLocalStorageRestoreANGLE)));
4271 if (isCallValid)
4272 {
4273 context->framebufferPixelLocalStorageRestore();
4274 }
4275 ANGLE_CAPTURE_GL(FramebufferPixelLocalStorageRestoreANGLE, isCallValid, context);
4276 }
4277 else
4278 {
4279 GenerateContextLostErrorOnCurrentGlobalContext();
4280 }
4281 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4282 }
4283
GL_GetFramebufferPixelLocalStorageParameterfvANGLE(GLint plane,GLenum pname,GLfloat * params)4284 void GL_APIENTRY GL_GetFramebufferPixelLocalStorageParameterfvANGLE(GLint plane,
4285 GLenum pname,
4286 GLfloat *params)
4287 {
4288 Context *context = GetValidGlobalContext();
4289 EVENT(context, GLGetFramebufferPixelLocalStorageParameterfvANGLE,
4290 "context = %d, plane = %d, pname = %s, params = 0x%016" PRIxPTR "", CID(context), plane,
4291 GLenumToString(GLESEnum::PLSQueryFloat, pname), (uintptr_t)params);
4292
4293 if (context)
4294 {
4295 SCOPED_SHARE_CONTEXT_LOCK(context);
4296 bool isCallValid =
4297 (context->skipValidation() ||
4298 ValidateGetFramebufferPixelLocalStorageParameterfvANGLE(
4299 context, angle::EntryPoint::GLGetFramebufferPixelLocalStorageParameterfvANGLE,
4300 plane, pname, params));
4301 if (isCallValid)
4302 {
4303 context->getFramebufferPixelLocalStorageParameterfv(plane, pname, params);
4304 }
4305 ANGLE_CAPTURE_GL(GetFramebufferPixelLocalStorageParameterfvANGLE, isCallValid, context,
4306 plane, pname, params);
4307 }
4308 else
4309 {
4310 GenerateContextLostErrorOnCurrentGlobalContext();
4311 }
4312 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4313 }
4314
GL_GetFramebufferPixelLocalStorageParameterivANGLE(GLint plane,GLenum pname,GLint * params)4315 void GL_APIENTRY GL_GetFramebufferPixelLocalStorageParameterivANGLE(GLint plane,
4316 GLenum pname,
4317 GLint *params)
4318 {
4319 Context *context = GetValidGlobalContext();
4320 EVENT(context, GLGetFramebufferPixelLocalStorageParameterivANGLE,
4321 "context = %d, plane = %d, pname = %s, params = 0x%016" PRIxPTR "", CID(context), plane,
4322 GLenumToString(GLESEnum::PLSQueryInt, pname), (uintptr_t)params);
4323
4324 if (context)
4325 {
4326 SCOPED_SHARE_CONTEXT_LOCK(context);
4327 bool isCallValid =
4328 (context->skipValidation() ||
4329 ValidateGetFramebufferPixelLocalStorageParameterivANGLE(
4330 context, angle::EntryPoint::GLGetFramebufferPixelLocalStorageParameterivANGLE,
4331 plane, pname, params));
4332 if (isCallValid)
4333 {
4334 context->getFramebufferPixelLocalStorageParameteriv(plane, pname, params);
4335 }
4336 ANGLE_CAPTURE_GL(GetFramebufferPixelLocalStorageParameterivANGLE, isCallValid, context,
4337 plane, pname, params);
4338 }
4339 else
4340 {
4341 GenerateContextLostErrorOnCurrentGlobalContext();
4342 }
4343 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4344 }
4345
GL_GetFramebufferPixelLocalStorageParameterfvRobustANGLE(GLint plane,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)4346 void GL_APIENTRY GL_GetFramebufferPixelLocalStorageParameterfvRobustANGLE(GLint plane,
4347 GLenum pname,
4348 GLsizei bufSize,
4349 GLsizei *length,
4350 GLfloat *params)
4351 {
4352 Context *context = GetValidGlobalContext();
4353 EVENT(context, GLGetFramebufferPixelLocalStorageParameterfvRobustANGLE,
4354 "context = %d, plane = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
4355 ", params = 0x%016" PRIxPTR "",
4356 CID(context), plane, GLenumToString(GLESEnum::PLSQueryFloat, pname), bufSize,
4357 (uintptr_t)length, (uintptr_t)params);
4358
4359 if (context)
4360 {
4361 SCOPED_SHARE_CONTEXT_LOCK(context);
4362 bool isCallValid =
4363 (context->skipValidation() ||
4364 ValidateGetFramebufferPixelLocalStorageParameterfvRobustANGLE(
4365 context,
4366 angle::EntryPoint::GLGetFramebufferPixelLocalStorageParameterfvRobustANGLE, plane,
4367 pname, bufSize, length, params));
4368 if (isCallValid)
4369 {
4370 context->getFramebufferPixelLocalStorageParameterfvRobust(plane, pname, bufSize, length,
4371 params);
4372 }
4373 ANGLE_CAPTURE_GL(GetFramebufferPixelLocalStorageParameterfvRobustANGLE, isCallValid,
4374 context, plane, pname, bufSize, length, params);
4375 }
4376 else
4377 {
4378 GenerateContextLostErrorOnCurrentGlobalContext();
4379 }
4380 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4381 }
4382
GL_GetFramebufferPixelLocalStorageParameterivRobustANGLE(GLint plane,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)4383 void GL_APIENTRY GL_GetFramebufferPixelLocalStorageParameterivRobustANGLE(GLint plane,
4384 GLenum pname,
4385 GLsizei bufSize,
4386 GLsizei *length,
4387 GLint *params)
4388 {
4389 Context *context = GetValidGlobalContext();
4390 EVENT(context, GLGetFramebufferPixelLocalStorageParameterivRobustANGLE,
4391 "context = %d, plane = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR
4392 ", params = 0x%016" PRIxPTR "",
4393 CID(context), plane, GLenumToString(GLESEnum::PLSQueryInt, pname), bufSize,
4394 (uintptr_t)length, (uintptr_t)params);
4395
4396 if (context)
4397 {
4398 SCOPED_SHARE_CONTEXT_LOCK(context);
4399 bool isCallValid =
4400 (context->skipValidation() ||
4401 ValidateGetFramebufferPixelLocalStorageParameterivRobustANGLE(
4402 context,
4403 angle::EntryPoint::GLGetFramebufferPixelLocalStorageParameterivRobustANGLE, plane,
4404 pname, bufSize, length, params));
4405 if (isCallValid)
4406 {
4407 context->getFramebufferPixelLocalStorageParameterivRobust(plane, pname, bufSize, length,
4408 params);
4409 }
4410 ANGLE_CAPTURE_GL(GetFramebufferPixelLocalStorageParameterivRobustANGLE, isCallValid,
4411 context, plane, pname, bufSize, length, params);
4412 }
4413 else
4414 {
4415 GenerateContextLostErrorOnCurrentGlobalContext();
4416 }
4417 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4418 }
4419
4420 // GL_ANGLE_stencil_texturing
4421
4422 // GL_ANGLE_texture_compression_dxt3
4423
4424 // GL_ANGLE_texture_compression_dxt5
4425
4426 // GL_ANGLE_texture_external_update
GL_TexImage2DExternalANGLE(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type)4427 void GL_APIENTRY GL_TexImage2DExternalANGLE(GLenum target,
4428 GLint level,
4429 GLint internalformat,
4430 GLsizei width,
4431 GLsizei height,
4432 GLint border,
4433 GLenum format,
4434 GLenum type)
4435 {
4436 Context *context = GetValidGlobalContext();
4437 EVENT(context, GLTexImage2DExternalANGLE,
4438 "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, "
4439 "border = %d, format = %s, type = %s",
4440 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, internalformat,
4441 width, height, border, GLenumToString(GLESEnum::PixelFormat, format),
4442 GLenumToString(GLESEnum::PixelType, type));
4443
4444 if (context)
4445 {
4446 TextureTarget targetPacked = PackParam<TextureTarget>(target);
4447 SCOPED_SHARE_CONTEXT_LOCK(context);
4448 bool isCallValid =
4449 (context->skipValidation() ||
4450 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4451 context->getMutableErrorSetForValidation(),
4452 angle::EntryPoint::GLTexImage2DExternalANGLE) &&
4453 ValidateTexImage2DExternalANGLE(context, angle::EntryPoint::GLTexImage2DExternalANGLE,
4454 targetPacked, level, internalformat, width, height,
4455 border, format, type)));
4456 if (isCallValid)
4457 {
4458 context->texImage2DExternal(targetPacked, level, internalformat, width, height, border,
4459 format, type);
4460 }
4461 ANGLE_CAPTURE_GL(TexImage2DExternalANGLE, isCallValid, context, targetPacked, level,
4462 internalformat, width, height, border, format, type);
4463 }
4464 else
4465 {
4466 GenerateContextLostErrorOnCurrentGlobalContext();
4467 }
4468 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
4469 }
4470
GL_InvalidateTextureANGLE(GLenum target)4471 void GL_APIENTRY GL_InvalidateTextureANGLE(GLenum target)
4472 {
4473 Context *context = GetValidGlobalContext();
4474 EVENT(context, GLInvalidateTextureANGLE, "context = %d, target = %s", CID(context),
4475 GLenumToString(GLESEnum::TextureTarget, target));
4476
4477 if (context)
4478 {
4479 TextureType targetPacked = PackParam<TextureType>(target);
4480 SCOPED_SHARE_CONTEXT_LOCK(context);
4481 bool isCallValid =
4482 (context->skipValidation() ||
4483 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4484 context->getMutableErrorSetForValidation(),
4485 angle::EntryPoint::GLInvalidateTextureANGLE) &&
4486 ValidateInvalidateTextureANGLE(context, angle::EntryPoint::GLInvalidateTextureANGLE,
4487 targetPacked)));
4488 if (isCallValid)
4489 {
4490 context->invalidateTexture(targetPacked);
4491 }
4492 ANGLE_CAPTURE_GL(InvalidateTextureANGLE, isCallValid, context, targetPacked);
4493 }
4494 else
4495 {
4496 GenerateContextLostErrorOnCurrentGlobalContext();
4497 }
4498 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4499 }
4500
4501 // GL_ANGLE_texture_multisample
GL_TexStorage2DMultisampleANGLE(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)4502 void GL_APIENTRY GL_TexStorage2DMultisampleANGLE(GLenum target,
4503 GLsizei samples,
4504 GLenum internalformat,
4505 GLsizei width,
4506 GLsizei height,
4507 GLboolean fixedsamplelocations)
4508 {
4509 Context *context = GetValidGlobalContext();
4510 EVENT(context, GLTexStorage2DMultisampleANGLE,
4511 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, "
4512 "fixedsamplelocations = %s",
4513 CID(context), GLenumToString(GLESEnum::AllEnums, target), samples,
4514 GLenumToString(GLESEnum::AllEnums, internalformat), width, height,
4515 GLbooleanToString(fixedsamplelocations));
4516
4517 if (context)
4518 {
4519 TextureType targetPacked = PackParam<TextureType>(target);
4520 SCOPED_SHARE_CONTEXT_LOCK(context);
4521 bool isCallValid =
4522 (context->skipValidation() ||
4523 (ValidatePixelLocalStorageInactive(
4524 context->getPrivateState(), context->getMutableErrorSetForValidation(),
4525 angle::EntryPoint::GLTexStorage2DMultisampleANGLE) &&
4526 ValidateTexStorage2DMultisampleANGLE(
4527 context, angle::EntryPoint::GLTexStorage2DMultisampleANGLE, targetPacked, samples,
4528 internalformat, width, height, fixedsamplelocations)));
4529 if (isCallValid)
4530 {
4531 context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height,
4532 fixedsamplelocations);
4533 }
4534 ANGLE_CAPTURE_GL(TexStorage2DMultisampleANGLE, isCallValid, context, targetPacked, samples,
4535 internalformat, width, height, fixedsamplelocations);
4536 }
4537 else
4538 {
4539 GenerateContextLostErrorOnCurrentGlobalContext();
4540 }
4541 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4542 }
4543
GL_GetMultisamplefvANGLE(GLenum pname,GLuint index,GLfloat * val)4544 void GL_APIENTRY GL_GetMultisamplefvANGLE(GLenum pname, GLuint index, GLfloat *val)
4545 {
4546 Context *context = GetValidGlobalContext();
4547 EVENT(context, GLGetMultisamplefvANGLE,
4548 "context = %d, pname = %s, index = %u, val = 0x%016" PRIxPTR "", CID(context),
4549 GLenumToString(GLESEnum::AllEnums, pname), index, (uintptr_t)val);
4550
4551 if (context)
4552 {
4553 SCOPED_SHARE_CONTEXT_LOCK(context);
4554 bool isCallValid =
4555 (context->skipValidation() ||
4556 ValidateGetMultisamplefvANGLE(context, angle::EntryPoint::GLGetMultisamplefvANGLE,
4557 pname, index, val));
4558 if (isCallValid)
4559 {
4560 context->getMultisamplefv(pname, index, val);
4561 }
4562 ANGLE_CAPTURE_GL(GetMultisamplefvANGLE, isCallValid, context, pname, index, val);
4563 }
4564 else
4565 {
4566 GenerateContextLostErrorOnCurrentGlobalContext();
4567 }
4568 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4569 }
4570
GL_SampleMaskiANGLE(GLuint maskNumber,GLbitfield mask)4571 void GL_APIENTRY GL_SampleMaskiANGLE(GLuint maskNumber, GLbitfield mask)
4572 {
4573 Context *context = GetValidGlobalContext();
4574 EVENT(context, GLSampleMaskiANGLE, "context = %d, maskNumber = %u, mask = %s", CID(context),
4575 maskNumber, GLbitfieldToString(GLESEnum::AllEnums, mask).c_str());
4576
4577 if (context)
4578 {
4579 bool isCallValid =
4580 (context->skipValidation() ||
4581 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4582 context->getMutableErrorSetForValidation(),
4583 angle::EntryPoint::GLSampleMaskiANGLE) &&
4584 ValidateSampleMaskiANGLE(context->getPrivateState(),
4585 context->getMutableErrorSetForValidation(),
4586 angle::EntryPoint::GLSampleMaskiANGLE, maskNumber, mask)));
4587 if (isCallValid)
4588 {
4589 ContextPrivateSampleMaski(context->getMutablePrivateState(),
4590 context->getMutablePrivateStateCache(), maskNumber, mask);
4591 }
4592 ANGLE_CAPTURE_GL(SampleMaskiANGLE, isCallValid, context, maskNumber, mask);
4593 }
4594 else
4595 {
4596 GenerateContextLostErrorOnCurrentGlobalContext();
4597 }
4598 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4599 }
4600
4601 // GetTexLevelParameterfvANGLE is already defined.
4602
4603 // GetTexLevelParameterivANGLE is already defined.
4604
4605 // GL_ANGLE_texture_usage
4606
4607 // GL_ANGLE_translated_shader_source
GL_GetTranslatedShaderSourceANGLE(GLuint shader,GLsizei bufSize,GLsizei * length,GLchar * source)4608 void GL_APIENTRY GL_GetTranslatedShaderSourceANGLE(GLuint shader,
4609 GLsizei bufSize,
4610 GLsizei *length,
4611 GLchar *source)
4612 {
4613 Context *context = GetValidGlobalContext();
4614 EVENT(context, GLGetTranslatedShaderSourceANGLE,
4615 "context = %d, shader = %u, bufSize = %d, length = 0x%016" PRIxPTR
4616 ", source = 0x%016" PRIxPTR "",
4617 CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)source);
4618
4619 if (context)
4620 {
4621 ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
4622 SCOPED_SHARE_CONTEXT_LOCK(context);
4623 bool isCallValid = (context->skipValidation() ||
4624 ValidateGetTranslatedShaderSourceANGLE(
4625 context, angle::EntryPoint::GLGetTranslatedShaderSourceANGLE,
4626 shaderPacked, bufSize, length, source));
4627 if (isCallValid)
4628 {
4629 context->getTranslatedShaderSource(shaderPacked, bufSize, length, source);
4630 }
4631 ANGLE_CAPTURE_GL(GetTranslatedShaderSourceANGLE, isCallValid, context, shaderPacked,
4632 bufSize, length, source);
4633 }
4634 else
4635 {
4636 GenerateContextLostErrorOnCurrentGlobalContext();
4637 }
4638 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4639 }
4640
4641 // GL_ANGLE_vulkan_image
GL_AcquireTexturesANGLE(GLuint numTextures,const GLuint * textures,const GLenum * layouts)4642 void GL_APIENTRY GL_AcquireTexturesANGLE(GLuint numTextures,
4643 const GLuint *textures,
4644 const GLenum *layouts)
4645 {
4646 Context *context = GetValidGlobalContext();
4647 EVENT(context, GLAcquireTexturesANGLE,
4648 "context = %d, numTextures = %u, textures = 0x%016" PRIxPTR ", layouts = 0x%016" PRIxPTR
4649 "",
4650 CID(context), numTextures, (uintptr_t)textures, (uintptr_t)layouts);
4651
4652 if (context)
4653 {
4654 const TextureID *texturesPacked = PackParam<const TextureID *>(textures);
4655 SCOPED_SHARE_CONTEXT_LOCK(context);
4656 bool isCallValid =
4657 (context->skipValidation() ||
4658 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4659 context->getMutableErrorSetForValidation(),
4660 angle::EntryPoint::GLAcquireTexturesANGLE) &&
4661 ValidateAcquireTexturesANGLE(context, angle::EntryPoint::GLAcquireTexturesANGLE,
4662 numTextures, texturesPacked, layouts)));
4663 if (isCallValid)
4664 {
4665 context->acquireTextures(numTextures, texturesPacked, layouts);
4666 }
4667 ANGLE_CAPTURE_GL(AcquireTexturesANGLE, isCallValid, context, numTextures, texturesPacked,
4668 layouts);
4669 }
4670 else
4671 {
4672 GenerateContextLostErrorOnCurrentGlobalContext();
4673 }
4674 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4675 }
4676
GL_ReleaseTexturesANGLE(GLuint numTextures,const GLuint * textures,GLenum * layouts)4677 void GL_APIENTRY GL_ReleaseTexturesANGLE(GLuint numTextures,
4678 const GLuint *textures,
4679 GLenum *layouts)
4680 {
4681 Context *context = GetValidGlobalContext();
4682 EVENT(context, GLReleaseTexturesANGLE,
4683 "context = %d, numTextures = %u, textures = 0x%016" PRIxPTR ", layouts = 0x%016" PRIxPTR
4684 "",
4685 CID(context), numTextures, (uintptr_t)textures, (uintptr_t)layouts);
4686
4687 if (context)
4688 {
4689 const TextureID *texturesPacked = PackParam<const TextureID *>(textures);
4690 SCOPED_SHARE_CONTEXT_LOCK(context);
4691 bool isCallValid =
4692 (context->skipValidation() ||
4693 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4694 context->getMutableErrorSetForValidation(),
4695 angle::EntryPoint::GLReleaseTexturesANGLE) &&
4696 ValidateReleaseTexturesANGLE(context, angle::EntryPoint::GLReleaseTexturesANGLE,
4697 numTextures, texturesPacked, layouts)));
4698 if (isCallValid)
4699 {
4700 context->releaseTextures(numTextures, texturesPacked, layouts);
4701 }
4702 ANGLE_CAPTURE_GL(ReleaseTexturesANGLE, isCallValid, context, numTextures, texturesPacked,
4703 layouts);
4704 }
4705 else
4706 {
4707 GenerateContextLostErrorOnCurrentGlobalContext();
4708 }
4709 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4710 }
4711
4712 // GL_ANGLE_yuv_internal_format
4713
4714 // GL_APPLE_clip_distance
4715
4716 // GL_ARB_sync
4717 // ClientWaitSync is already defined.
4718
4719 // DeleteSync is already defined.
4720
4721 // FenceSync is already defined.
4722
4723 // GetInteger64v is already defined.
4724
4725 // GetSynciv is already defined.
4726
4727 // IsSync is already defined.
4728
4729 // WaitSync is already defined.
4730
4731 // GL_ARM_shader_framebuffer_fetch
4732
4733 // GL_CHROMIUM_bind_uniform_location
GL_BindUniformLocationCHROMIUM(GLuint program,GLint location,const GLchar * name)4734 void GL_APIENTRY GL_BindUniformLocationCHROMIUM(GLuint program, GLint location, const GLchar *name)
4735 {
4736 Context *context = GetValidGlobalContext();
4737 EVENT(context, GLBindUniformLocationCHROMIUM,
4738 "context = %d, program = %u, location = %d, name = 0x%016" PRIxPTR "", CID(context),
4739 program, location, (uintptr_t)name);
4740
4741 if (context)
4742 {
4743 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
4744 UniformLocation locationPacked = PackParam<UniformLocation>(location);
4745 SCOPED_SHARE_CONTEXT_LOCK(context);
4746 bool isCallValid =
4747 (context->skipValidation() ||
4748 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4749 context->getMutableErrorSetForValidation(),
4750 angle::EntryPoint::GLBindUniformLocationCHROMIUM) &&
4751 ValidateBindUniformLocationCHROMIUM(context,
4752 angle::EntryPoint::GLBindUniformLocationCHROMIUM,
4753 programPacked, locationPacked, name)));
4754 if (isCallValid)
4755 {
4756 context->bindUniformLocation(programPacked, locationPacked, name);
4757 }
4758 ANGLE_CAPTURE_GL(BindUniformLocationCHROMIUM, isCallValid, context, programPacked,
4759 locationPacked, name);
4760 }
4761 else
4762 {
4763 GenerateContextLostErrorOnCurrentGlobalContext();
4764 }
4765 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4766 }
4767
4768 // GL_CHROMIUM_copy_compressed_texture
GL_CompressedCopyTextureCHROMIUM(GLuint sourceId,GLuint destId)4769 void GL_APIENTRY GL_CompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId)
4770 {
4771 Context *context = GetValidGlobalContext();
4772 EVENT(context, GLCompressedCopyTextureCHROMIUM, "context = %d, sourceId = %u, destId = %u",
4773 CID(context), sourceId, destId);
4774
4775 if (context)
4776 {
4777 TextureID sourceIdPacked = PackParam<TextureID>(sourceId);
4778 TextureID destIdPacked = PackParam<TextureID>(destId);
4779 SCOPED_SHARE_CONTEXT_LOCK(context);
4780 bool isCallValid =
4781 (context->skipValidation() ||
4782 (ValidatePixelLocalStorageInactive(
4783 context->getPrivateState(), context->getMutableErrorSetForValidation(),
4784 angle::EntryPoint::GLCompressedCopyTextureCHROMIUM) &&
4785 ValidateCompressedCopyTextureCHROMIUM(
4786 context, angle::EntryPoint::GLCompressedCopyTextureCHROMIUM, sourceIdPacked,
4787 destIdPacked)));
4788 if (isCallValid)
4789 {
4790 context->compressedCopyTexture(sourceIdPacked, destIdPacked);
4791 }
4792 ANGLE_CAPTURE_GL(CompressedCopyTextureCHROMIUM, isCallValid, context, sourceIdPacked,
4793 destIdPacked);
4794 }
4795 else
4796 {
4797 GenerateContextLostErrorOnCurrentGlobalContext();
4798 }
4799 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4800 }
4801
4802 // 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)4803 void GL_APIENTRY GL_CopyTextureCHROMIUM(GLuint sourceId,
4804 GLint sourceLevel,
4805 GLenum destTarget,
4806 GLuint destId,
4807 GLint destLevel,
4808 GLint internalFormat,
4809 GLenum destType,
4810 GLboolean unpackFlipY,
4811 GLboolean unpackPremultiplyAlpha,
4812 GLboolean unpackUnmultiplyAlpha)
4813 {
4814 Context *context = GetValidGlobalContext();
4815 EVENT(context, GLCopyTextureCHROMIUM,
4816 "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel "
4817 "= %d, internalFormat = %d, destType = %s, unpackFlipY = %s, unpackPremultiplyAlpha = "
4818 "%s, unpackUnmultiplyAlpha = %s",
4819 CID(context), sourceId, sourceLevel, GLenumToString(GLESEnum::AllEnums, destTarget),
4820 destId, destLevel, internalFormat, GLenumToString(GLESEnum::AllEnums, destType),
4821 GLbooleanToString(unpackFlipY), GLbooleanToString(unpackPremultiplyAlpha),
4822 GLbooleanToString(unpackUnmultiplyAlpha));
4823
4824 if (context)
4825 {
4826 TextureID sourceIdPacked = PackParam<TextureID>(sourceId);
4827 TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget);
4828 TextureID destIdPacked = PackParam<TextureID>(destId);
4829 SCOPED_SHARE_CONTEXT_LOCK(context);
4830 bool isCallValid =
4831 (context->skipValidation() ||
4832 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4833 context->getMutableErrorSetForValidation(),
4834 angle::EntryPoint::GLCopyTextureCHROMIUM) &&
4835 ValidateCopyTextureCHROMIUM(
4836 context, angle::EntryPoint::GLCopyTextureCHROMIUM, sourceIdPacked, sourceLevel,
4837 destTargetPacked, destIdPacked, destLevel, internalFormat, destType, unpackFlipY,
4838 unpackPremultiplyAlpha, unpackUnmultiplyAlpha)));
4839 if (isCallValid)
4840 {
4841 context->copyTexture(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
4842 destLevel, internalFormat, destType, unpackFlipY,
4843 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
4844 }
4845 ANGLE_CAPTURE_GL(CopyTextureCHROMIUM, isCallValid, context, sourceIdPacked, sourceLevel,
4846 destTargetPacked, destIdPacked, destLevel, internalFormat, destType,
4847 unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
4848 }
4849 else
4850 {
4851 GenerateContextLostErrorOnCurrentGlobalContext();
4852 }
4853 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4854 }
4855
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)4856 void GL_APIENTRY GL_CopySubTextureCHROMIUM(GLuint sourceId,
4857 GLint sourceLevel,
4858 GLenum destTarget,
4859 GLuint destId,
4860 GLint destLevel,
4861 GLint xoffset,
4862 GLint yoffset,
4863 GLint x,
4864 GLint y,
4865 GLint width,
4866 GLint height,
4867 GLboolean unpackFlipY,
4868 GLboolean unpackPremultiplyAlpha,
4869 GLboolean unpackUnmultiplyAlpha)
4870 {
4871 Context *context = GetValidGlobalContext();
4872 EVENT(context, GLCopySubTextureCHROMIUM,
4873 "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel "
4874 "= %d, xoffset = %d, yoffset = %d, x = %d, y = %d, width = %d, height = %d, unpackFlipY "
4875 "= %s, unpackPremultiplyAlpha = %s, unpackUnmultiplyAlpha = %s",
4876 CID(context), sourceId, sourceLevel, GLenumToString(GLESEnum::AllEnums, destTarget),
4877 destId, destLevel, xoffset, yoffset, x, y, width, height, GLbooleanToString(unpackFlipY),
4878 GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha));
4879
4880 if (context)
4881 {
4882 TextureID sourceIdPacked = PackParam<TextureID>(sourceId);
4883 TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget);
4884 TextureID destIdPacked = PackParam<TextureID>(destId);
4885 SCOPED_SHARE_CONTEXT_LOCK(context);
4886 bool isCallValid =
4887 (context->skipValidation() ||
4888 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4889 context->getMutableErrorSetForValidation(),
4890 angle::EntryPoint::GLCopySubTextureCHROMIUM) &&
4891 ValidateCopySubTextureCHROMIUM(
4892 context, angle::EntryPoint::GLCopySubTextureCHROMIUM, sourceIdPacked, sourceLevel,
4893 destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, x, y, width, height,
4894 unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha)));
4895 if (isCallValid)
4896 {
4897 context->copySubTexture(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked,
4898 destLevel, xoffset, yoffset, x, y, width, height, unpackFlipY,
4899 unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
4900 }
4901 ANGLE_CAPTURE_GL(CopySubTextureCHROMIUM, isCallValid, context, sourceIdPacked, sourceLevel,
4902 destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, x, y, width,
4903 height, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
4904 }
4905 else
4906 {
4907 GenerateContextLostErrorOnCurrentGlobalContext();
4908 }
4909 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4910 }
4911
4912 // GL_CHROMIUM_framebuffer_mixed_samples
GL_CoverageModulationCHROMIUM(GLenum components)4913 void GL_APIENTRY GL_CoverageModulationCHROMIUM(GLenum components)
4914 {
4915 Context *context = GetValidGlobalContext();
4916 EVENT(context, GLCoverageModulationCHROMIUM, "context = %d, components = %s", CID(context),
4917 GLenumToString(GLESEnum::AllEnums, components));
4918
4919 if (context)
4920 {
4921 bool isCallValid =
4922 (context->skipValidation() ||
4923 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4924 context->getMutableErrorSetForValidation(),
4925 angle::EntryPoint::GLCoverageModulationCHROMIUM) &&
4926 ValidateCoverageModulationCHROMIUM(
4927 context->getPrivateState(), context->getMutableErrorSetForValidation(),
4928 angle::EntryPoint::GLCoverageModulationCHROMIUM, components)));
4929 if (isCallValid)
4930 {
4931 ContextPrivateCoverageModulation(context->getMutablePrivateState(),
4932 context->getMutablePrivateStateCache(), components);
4933 }
4934 ANGLE_CAPTURE_GL(CoverageModulationCHROMIUM, isCallValid, context, components);
4935 }
4936 else
4937 {
4938 GenerateContextLostErrorOnCurrentGlobalContext();
4939 }
4940 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4941 }
4942
4943 // GL_CHROMIUM_lose_context
GL_LoseContextCHROMIUM(GLenum current,GLenum other)4944 void GL_APIENTRY GL_LoseContextCHROMIUM(GLenum current, GLenum other)
4945 {
4946 Context *context = GetValidGlobalContext();
4947 EVENT(context, GLLoseContextCHROMIUM, "context = %d, current = %s, other = %s", CID(context),
4948 GLenumToString(GLESEnum::GraphicsResetStatus, current),
4949 GLenumToString(GLESEnum::GraphicsResetStatus, other));
4950
4951 if (context)
4952 {
4953 GraphicsResetStatus currentPacked = PackParam<GraphicsResetStatus>(current);
4954 GraphicsResetStatus otherPacked = PackParam<GraphicsResetStatus>(other);
4955 SCOPED_SHARE_CONTEXT_LOCK(context);
4956 bool isCallValid =
4957 (context->skipValidation() ||
4958 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4959 context->getMutableErrorSetForValidation(),
4960 angle::EntryPoint::GLLoseContextCHROMIUM) &&
4961 ValidateLoseContextCHROMIUM(context, angle::EntryPoint::GLLoseContextCHROMIUM,
4962 currentPacked, otherPacked)));
4963 if (isCallValid)
4964 {
4965 context->loseContext(currentPacked, otherPacked);
4966 }
4967 ANGLE_CAPTURE_GL(LoseContextCHROMIUM, isCallValid, context, currentPacked, otherPacked);
4968 }
4969 else
4970 {
4971 GenerateContextLostErrorOnCurrentGlobalContext();
4972 }
4973 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
4974 }
4975
4976 // GL_EXT_EGL_image_array
4977
4978 // GL_EXT_EGL_image_storage
GL_EGLImageTargetTexStorageEXT(GLenum target,GLeglImageOES image,const GLint * attrib_list)4979 void GL_APIENTRY GL_EGLImageTargetTexStorageEXT(GLenum target,
4980 GLeglImageOES image,
4981 const GLint *attrib_list)
4982 {
4983 Context *context = GetValidGlobalContext();
4984 EVENT(context, GLEGLImageTargetTexStorageEXT,
4985 "context = %d, target = %s, image = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "",
4986 CID(context), GLenumToString(GLESEnum::AllEnums, target), (uintptr_t)image,
4987 (uintptr_t)attrib_list);
4988
4989 if (context)
4990 {
4991 egl::ImageID imagePacked = PackParam<egl::ImageID>(image);
4992 SCOPED_EGL_IMAGE_SHARE_CONTEXT_LOCK(context, imagePacked);
4993 bool isCallValid =
4994 (context->skipValidation() ||
4995 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
4996 context->getMutableErrorSetForValidation(),
4997 angle::EntryPoint::GLEGLImageTargetTexStorageEXT) &&
4998 ValidateEGLImageTargetTexStorageEXT(context,
4999 angle::EntryPoint::GLEGLImageTargetTexStorageEXT,
5000 target, imagePacked, attrib_list)));
5001 if (isCallValid)
5002 {
5003 context->eGLImageTargetTexStorage(target, imagePacked, attrib_list);
5004 }
5005 ANGLE_CAPTURE_GL(EGLImageTargetTexStorageEXT, isCallValid, context, target, imagePacked,
5006 attrib_list);
5007 }
5008 else
5009 {
5010 GenerateContextLostErrorOnCurrentGlobalContext();
5011 }
5012 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5013 }
5014
GL_EGLImageTargetTextureStorageEXT(GLuint texture,GLeglImageOES image,const GLint * attrib_list)5015 void GL_APIENTRY GL_EGLImageTargetTextureStorageEXT(GLuint texture,
5016 GLeglImageOES image,
5017 const GLint *attrib_list)
5018 {
5019 Context *context = GetValidGlobalContext();
5020 EVENT(context, GLEGLImageTargetTextureStorageEXT,
5021 "context = %d, texture = %u, image = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "",
5022 CID(context), texture, (uintptr_t)image, (uintptr_t)attrib_list);
5023
5024 if (context)
5025 {
5026 egl::ImageID imagePacked = PackParam<egl::ImageID>(image);
5027 SCOPED_EGL_IMAGE_SHARE_CONTEXT_LOCK(context, imagePacked);
5028 bool isCallValid =
5029 (context->skipValidation() ||
5030 (ValidatePixelLocalStorageInactive(
5031 context->getPrivateState(), context->getMutableErrorSetForValidation(),
5032 angle::EntryPoint::GLEGLImageTargetTextureStorageEXT) &&
5033 ValidateEGLImageTargetTextureStorageEXT(
5034 context, angle::EntryPoint::GLEGLImageTargetTextureStorageEXT, texture,
5035 imagePacked, attrib_list)));
5036 if (isCallValid)
5037 {
5038 context->eGLImageTargetTextureStorage(texture, imagePacked, attrib_list);
5039 }
5040 ANGLE_CAPTURE_GL(EGLImageTargetTextureStorageEXT, isCallValid, context, texture,
5041 imagePacked, attrib_list);
5042 }
5043 else
5044 {
5045 GenerateContextLostErrorOnCurrentGlobalContext();
5046 }
5047 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5048 }
5049
5050 // GL_EXT_YUV_target
5051
5052 // GL_EXT_base_instance
GL_DrawArraysInstancedBaseInstanceEXT(GLenum mode,GLint first,GLsizei count,GLsizei instancecount,GLuint baseinstance)5053 void GL_APIENTRY GL_DrawArraysInstancedBaseInstanceEXT(GLenum mode,
5054 GLint first,
5055 GLsizei count,
5056 GLsizei instancecount,
5057 GLuint baseinstance)
5058 {
5059 Context *context = GetValidGlobalContext();
5060 EVENT(context, GLDrawArraysInstancedBaseInstanceEXT,
5061 "context = %d, mode = %s, first = %d, count = %d, instancecount = %d, baseinstance = %u",
5062 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), first, count, instancecount,
5063 baseinstance);
5064
5065 if (context)
5066 {
5067 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
5068 SCOPED_SHARE_CONTEXT_LOCK(context);
5069 bool isCallValid = (context->skipValidation() ||
5070 ValidateDrawArraysInstancedBaseInstanceEXT(
5071 context, angle::EntryPoint::GLDrawArraysInstancedBaseInstanceEXT,
5072 modePacked, first, count, instancecount, baseinstance));
5073 if (isCallValid)
5074 {
5075 context->drawArraysInstancedBaseInstance(modePacked, first, count, instancecount,
5076 baseinstance);
5077 }
5078 ANGLE_CAPTURE_GL(DrawArraysInstancedBaseInstanceEXT, isCallValid, context, modePacked,
5079 first, count, instancecount, baseinstance);
5080 }
5081 else
5082 {
5083 GenerateContextLostErrorOnCurrentGlobalContext();
5084 }
5085 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5086 }
5087
GL_DrawElementsInstancedBaseInstanceEXT(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount,GLuint baseinstance)5088 void GL_APIENTRY GL_DrawElementsInstancedBaseInstanceEXT(GLenum mode,
5089 GLsizei count,
5090 GLenum type,
5091 const void *indices,
5092 GLsizei instancecount,
5093 GLuint baseinstance)
5094 {
5095 Context *context = GetValidGlobalContext();
5096 EVENT(context, GLDrawElementsInstancedBaseInstanceEXT,
5097 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
5098 ", instancecount = %d, baseinstance = %u",
5099 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count,
5100 GLenumToString(GLESEnum::PrimitiveType, type), (uintptr_t)indices, instancecount,
5101 baseinstance);
5102
5103 if (context)
5104 {
5105 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
5106 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
5107 SCOPED_SHARE_CONTEXT_LOCK(context);
5108 bool isCallValid =
5109 (context->skipValidation() ||
5110 ValidateDrawElementsInstancedBaseInstanceEXT(
5111 context, angle::EntryPoint::GLDrawElementsInstancedBaseInstanceEXT, modePacked,
5112 count, typePacked, indices, instancecount, baseinstance));
5113 if (isCallValid)
5114 {
5115 context->drawElementsInstancedBaseInstance(modePacked, count, typePacked, indices,
5116 instancecount, baseinstance);
5117 }
5118 ANGLE_CAPTURE_GL(DrawElementsInstancedBaseInstanceEXT, isCallValid, context, modePacked,
5119 count, typePacked, indices, instancecount, baseinstance);
5120 }
5121 else
5122 {
5123 GenerateContextLostErrorOnCurrentGlobalContext();
5124 }
5125 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5126 }
5127
GL_DrawElementsInstancedBaseVertexBaseInstanceEXT(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount,GLint basevertex,GLuint baseinstance)5128 void GL_APIENTRY GL_DrawElementsInstancedBaseVertexBaseInstanceEXT(GLenum mode,
5129 GLsizei count,
5130 GLenum type,
5131 const void *indices,
5132 GLsizei instancecount,
5133 GLint basevertex,
5134 GLuint baseinstance)
5135 {
5136 Context *context = GetValidGlobalContext();
5137 EVENT(context, GLDrawElementsInstancedBaseVertexBaseInstanceEXT,
5138 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
5139 ", instancecount = %d, basevertex = %d, baseinstance = %u",
5140 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count,
5141 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instancecount,
5142 basevertex, baseinstance);
5143
5144 if (context)
5145 {
5146 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
5147 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
5148 SCOPED_SHARE_CONTEXT_LOCK(context);
5149 bool isCallValid =
5150 (context->skipValidation() ||
5151 ValidateDrawElementsInstancedBaseVertexBaseInstanceEXT(
5152 context, angle::EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstanceEXT,
5153 modePacked, count, typePacked, indices, instancecount, basevertex, baseinstance));
5154 if (isCallValid)
5155 {
5156 context->drawElementsInstancedBaseVertexBaseInstance(
5157 modePacked, count, typePacked, indices, instancecount, basevertex, baseinstance);
5158 }
5159 ANGLE_CAPTURE_GL(DrawElementsInstancedBaseVertexBaseInstanceEXT, isCallValid, context,
5160 modePacked, count, typePacked, indices, instancecount, basevertex,
5161 baseinstance);
5162 }
5163 else
5164 {
5165 GenerateContextLostErrorOnCurrentGlobalContext();
5166 }
5167 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5168 }
5169
5170 // GL_EXT_blend_func_extended
GL_BindFragDataLocationEXT(GLuint program,GLuint color,const GLchar * name)5171 void GL_APIENTRY GL_BindFragDataLocationEXT(GLuint program, GLuint color, const GLchar *name)
5172 {
5173 Context *context = GetValidGlobalContext();
5174 EVENT(context, GLBindFragDataLocationEXT,
5175 "context = %d, program = %u, color = %u, name = 0x%016" PRIxPTR "", CID(context), program,
5176 color, (uintptr_t)name);
5177
5178 if (context)
5179 {
5180 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
5181 SCOPED_SHARE_CONTEXT_LOCK(context);
5182 bool isCallValid =
5183 (context->skipValidation() ||
5184 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5185 context->getMutableErrorSetForValidation(),
5186 angle::EntryPoint::GLBindFragDataLocationEXT) &&
5187 ValidateBindFragDataLocationEXT(context, angle::EntryPoint::GLBindFragDataLocationEXT,
5188 programPacked, color, name)));
5189 if (isCallValid)
5190 {
5191 context->bindFragDataLocation(programPacked, color, name);
5192 }
5193 ANGLE_CAPTURE_GL(BindFragDataLocationEXT, isCallValid, context, programPacked, color, name);
5194 }
5195 else
5196 {
5197 GenerateContextLostErrorOnCurrentGlobalContext();
5198 }
5199 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5200 }
5201
GL_BindFragDataLocationIndexedEXT(GLuint program,GLuint colorNumber,GLuint index,const GLchar * name)5202 void GL_APIENTRY GL_BindFragDataLocationIndexedEXT(GLuint program,
5203 GLuint colorNumber,
5204 GLuint index,
5205 const GLchar *name)
5206 {
5207 Context *context = GetValidGlobalContext();
5208 EVENT(context, GLBindFragDataLocationIndexedEXT,
5209 "context = %d, program = %u, colorNumber = %u, index = %u, name = 0x%016" PRIxPTR "",
5210 CID(context), program, colorNumber, index, (uintptr_t)name);
5211
5212 if (context)
5213 {
5214 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
5215 SCOPED_SHARE_CONTEXT_LOCK(context);
5216 bool isCallValid =
5217 (context->skipValidation() ||
5218 (ValidatePixelLocalStorageInactive(
5219 context->getPrivateState(), context->getMutableErrorSetForValidation(),
5220 angle::EntryPoint::GLBindFragDataLocationIndexedEXT) &&
5221 ValidateBindFragDataLocationIndexedEXT(
5222 context, angle::EntryPoint::GLBindFragDataLocationIndexedEXT, programPacked,
5223 colorNumber, index, name)));
5224 if (isCallValid)
5225 {
5226 context->bindFragDataLocationIndexed(programPacked, colorNumber, index, name);
5227 }
5228 ANGLE_CAPTURE_GL(BindFragDataLocationIndexedEXT, isCallValid, context, programPacked,
5229 colorNumber, index, name);
5230 }
5231 else
5232 {
5233 GenerateContextLostErrorOnCurrentGlobalContext();
5234 }
5235 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5236 }
5237
GL_GetFragDataIndexEXT(GLuint program,const GLchar * name)5238 GLint GL_APIENTRY GL_GetFragDataIndexEXT(GLuint program, const GLchar *name)
5239 {
5240 Context *context = GetValidGlobalContext();
5241 EVENT(context, GLGetFragDataIndexEXT, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
5242 CID(context), program, (uintptr_t)name);
5243
5244 GLint returnValue;
5245 if (context)
5246 {
5247 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
5248 SCOPED_SHARE_CONTEXT_LOCK(context);
5249 bool isCallValid =
5250 (context->skipValidation() ||
5251 ValidateGetFragDataIndexEXT(context, angle::EntryPoint::GLGetFragDataIndexEXT,
5252 programPacked, name));
5253 if (isCallValid)
5254 {
5255 returnValue = context->getFragDataIndex(programPacked, name);
5256 }
5257 else
5258 {
5259 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataIndexEXT, GLint>();
5260 }
5261 ANGLE_CAPTURE_GL(GetFragDataIndexEXT, isCallValid, context, programPacked, name,
5262 returnValue);
5263 }
5264 else
5265 {
5266 GenerateContextLostErrorOnCurrentGlobalContext();
5267 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataIndexEXT, GLint>();
5268 }
5269 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5270 return returnValue;
5271 }
5272
GL_GetProgramResourceLocationIndexEXT(GLuint program,GLenum programInterface,const GLchar * name)5273 GLint GL_APIENTRY GL_GetProgramResourceLocationIndexEXT(GLuint program,
5274 GLenum programInterface,
5275 const GLchar *name)
5276 {
5277 Context *context = GetValidGlobalContext();
5278 EVENT(context, GLGetProgramResourceLocationIndexEXT,
5279 "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "",
5280 CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface),
5281 (uintptr_t)name);
5282
5283 GLint returnValue;
5284 if (context)
5285 {
5286 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
5287 SCOPED_SHARE_CONTEXT_LOCK(context);
5288 bool isCallValid = (context->skipValidation() ||
5289 ValidateGetProgramResourceLocationIndexEXT(
5290 context, angle::EntryPoint::GLGetProgramResourceLocationIndexEXT,
5291 programPacked, programInterface, name));
5292 if (isCallValid)
5293 {
5294 returnValue =
5295 context->getProgramResourceLocationIndex(programPacked, programInterface, name);
5296 }
5297 else
5298 {
5299 returnValue =
5300 GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocationIndexEXT,
5301 GLint>();
5302 }
5303 ANGLE_CAPTURE_GL(GetProgramResourceLocationIndexEXT, isCallValid, context, programPacked,
5304 programInterface, name, returnValue);
5305 }
5306 else
5307 {
5308 GenerateContextLostErrorOnCurrentGlobalContext();
5309 returnValue =
5310 GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocationIndexEXT, GLint>();
5311 }
5312 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5313 return returnValue;
5314 }
5315
5316 // GL_EXT_blend_minmax
5317
5318 // GL_EXT_buffer_storage
GL_BufferStorageEXT(GLenum target,GLsizeiptr size,const void * data,GLbitfield flags)5319 void GL_APIENTRY GL_BufferStorageEXT(GLenum target,
5320 GLsizeiptr size,
5321 const void *data,
5322 GLbitfield flags)
5323 {
5324 Context *context = GetValidGlobalContext();
5325 EVENT(context, GLBufferStorageEXT,
5326 "context = %d, target = %s, size = %llu, data = 0x%016" PRIxPTR ", flags = %s",
5327 CID(context), GLenumToString(GLESEnum::BufferStorageTarget, target),
5328 static_cast<unsigned long long>(size), (uintptr_t)data,
5329 GLbitfieldToString(GLESEnum::BufferStorageMask, flags).c_str());
5330
5331 if (context)
5332 {
5333 BufferBinding targetPacked = PackParam<BufferBinding>(target);
5334 SCOPED_SHARE_CONTEXT_LOCK(context);
5335 bool isCallValid =
5336 (context->skipValidation() ||
5337 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5338 context->getMutableErrorSetForValidation(),
5339 angle::EntryPoint::GLBufferStorageEXT) &&
5340 ValidateBufferStorageEXT(context, angle::EntryPoint::GLBufferStorageEXT, targetPacked,
5341 size, data, flags)));
5342 if (isCallValid)
5343 {
5344 context->bufferStorage(targetPacked, size, data, flags);
5345 }
5346 ANGLE_CAPTURE_GL(BufferStorageEXT, isCallValid, context, targetPacked, size, data, flags);
5347 }
5348 else
5349 {
5350 GenerateContextLostErrorOnCurrentGlobalContext();
5351 }
5352 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5353 }
5354
5355 // GL_EXT_clip_control
GL_ClipControlEXT(GLenum origin,GLenum depth)5356 void GL_APIENTRY GL_ClipControlEXT(GLenum origin, GLenum depth)
5357 {
5358 Context *context = GetValidGlobalContext();
5359 EVENT(context, GLClipControlEXT, "context = %d, origin = %s, depth = %s", CID(context),
5360 GLenumToString(GLESEnum::AllEnums, origin), GLenumToString(GLESEnum::AllEnums, depth));
5361
5362 if (context)
5363 {
5364 ClipOrigin originPacked = PackParam<ClipOrigin>(origin);
5365 ClipDepthMode depthPacked = PackParam<ClipDepthMode>(depth);
5366 bool isCallValid =
5367 (context->skipValidation() ||
5368 ValidateClipControlEXT(
5369 context->getPrivateState(), context->getMutableErrorSetForValidation(),
5370 angle::EntryPoint::GLClipControlEXT, originPacked, depthPacked));
5371 if (isCallValid)
5372 {
5373 ContextPrivateClipControl(context->getMutablePrivateState(),
5374 context->getMutablePrivateStateCache(), originPacked,
5375 depthPacked);
5376 }
5377 ANGLE_CAPTURE_GL(ClipControlEXT, isCallValid, context, originPacked, depthPacked);
5378 }
5379 else
5380 {
5381 GenerateContextLostErrorOnCurrentGlobalContext();
5382 }
5383 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5384 }
5385
5386 // GL_EXT_clip_cull_distance
5387
5388 // GL_EXT_color_buffer_float
5389
5390 // GL_EXT_color_buffer_half_float
5391
5392 // GL_EXT_conservative_depth
5393
5394 // 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)5395 void GL_APIENTRY GL_CopyImageSubDataEXT(GLuint srcName,
5396 GLenum srcTarget,
5397 GLint srcLevel,
5398 GLint srcX,
5399 GLint srcY,
5400 GLint srcZ,
5401 GLuint dstName,
5402 GLenum dstTarget,
5403 GLint dstLevel,
5404 GLint dstX,
5405 GLint dstY,
5406 GLint dstZ,
5407 GLsizei srcWidth,
5408 GLsizei srcHeight,
5409 GLsizei srcDepth)
5410 {
5411 Context *context = GetValidGlobalContext();
5412 EVENT(context, GLCopyImageSubDataEXT,
5413 "context = %d, srcName = %u, srcTarget = %s, srcLevel = %d, srcX = %d, srcY = %d, srcZ = "
5414 "%d, dstName = %u, dstTarget = %s, dstLevel = %d, dstX = %d, dstY = %d, dstZ = %d, "
5415 "srcWidth = %d, srcHeight = %d, srcDepth = %d",
5416 CID(context), srcName, GLenumToString(GLESEnum::CopyBufferSubDataTarget, srcTarget),
5417 srcLevel, srcX, srcY, srcZ, dstName,
5418 GLenumToString(GLESEnum::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY, dstZ,
5419 srcWidth, srcHeight, srcDepth);
5420
5421 if (context)
5422 {
5423 SCOPED_SHARE_CONTEXT_LOCK(context);
5424 bool isCallValid =
5425 (context->skipValidation() ||
5426 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5427 context->getMutableErrorSetForValidation(),
5428 angle::EntryPoint::GLCopyImageSubDataEXT) &&
5429 ValidateCopyImageSubDataEXT(context, angle::EntryPoint::GLCopyImageSubDataEXT,
5430 srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
5431 dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
5432 srcHeight, srcDepth)));
5433 if (isCallValid)
5434 {
5435 context->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
5436 dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
5437 srcDepth);
5438 }
5439 ANGLE_CAPTURE_GL(CopyImageSubDataEXT, isCallValid, context, srcName, srcTarget, srcLevel,
5440 srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
5441 srcHeight, srcDepth);
5442 }
5443 else
5444 {
5445 GenerateContextLostErrorOnCurrentGlobalContext();
5446 }
5447 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5448 }
5449
5450 // GL_EXT_debug_label
5451 void GL_APIENTRY
GL_GetObjectLabelEXT(GLenum type,GLuint object,GLsizei bufSize,GLsizei * length,GLchar * label)5452 GL_GetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label)
5453 {
5454 Context *context = GetValidGlobalContext();
5455 EVENT(context, GLGetObjectLabelEXT,
5456 "context = %d, type = %s, object = %u, bufSize = %d, length = 0x%016" PRIxPTR
5457 ", label = 0x%016" PRIxPTR "",
5458 CID(context), GLenumToString(GLESEnum::AllEnums, type), object, bufSize,
5459 (uintptr_t)length, (uintptr_t)label);
5460
5461 if (context)
5462 {
5463 SCOPED_SHARE_CONTEXT_LOCK(context);
5464 bool isCallValid =
5465 (context->skipValidation() ||
5466 ValidateGetObjectLabelEXT(context, angle::EntryPoint::GLGetObjectLabelEXT, type,
5467 object, bufSize, length, label));
5468 if (isCallValid)
5469 {
5470 context->getObjectLabel(type, object, bufSize, length, label);
5471 }
5472 ANGLE_CAPTURE_GL(GetObjectLabelEXT, isCallValid, context, type, object, bufSize, length,
5473 label);
5474 }
5475 else
5476 {
5477 GenerateContextLostErrorOnCurrentGlobalContext();
5478 }
5479 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5480 }
5481
GL_LabelObjectEXT(GLenum type,GLuint object,GLsizei length,const GLchar * label)5482 void GL_APIENTRY GL_LabelObjectEXT(GLenum type, GLuint object, GLsizei length, const GLchar *label)
5483 {
5484 Context *context = GetValidGlobalContext();
5485 EVENT(context, GLLabelObjectEXT,
5486 "context = %d, type = %s, object = %u, length = %d, label = 0x%016" PRIxPTR "",
5487 CID(context), GLenumToString(GLESEnum::AllEnums, type), object, length, (uintptr_t)label);
5488
5489 if (context)
5490 {
5491 SCOPED_SHARE_CONTEXT_LOCK(context);
5492 bool isCallValid =
5493 (context->skipValidation() ||
5494 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5495 context->getMutableErrorSetForValidation(),
5496 angle::EntryPoint::GLLabelObjectEXT) &&
5497 ValidateLabelObjectEXT(context, angle::EntryPoint::GLLabelObjectEXT, type, object,
5498 length, label)));
5499 if (isCallValid)
5500 {
5501 context->labelObject(type, object, length, label);
5502 }
5503 ANGLE_CAPTURE_GL(LabelObjectEXT, isCallValid, context, type, object, length, label);
5504 }
5505 else
5506 {
5507 GenerateContextLostErrorOnCurrentGlobalContext();
5508 }
5509 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5510 }
5511
5512 // GL_EXT_debug_marker
GL_InsertEventMarkerEXT(GLsizei length,const GLchar * marker)5513 void GL_APIENTRY GL_InsertEventMarkerEXT(GLsizei length, const GLchar *marker)
5514 {
5515 Context *context = GetValidGlobalContext();
5516 // Don't run the EVENT() macro on the EXT_debug_marker entry points.
5517 // It can interfere with the debug events being set by the caller.
5518 // EVENT(context, GLInsertEventMarkerEXT, "context = %d, length = %d, marker = 0x%016" PRIxPTR
5519 // "", CID(context), length, (uintptr_t)marker);
5520
5521 if (context)
5522 {
5523 SCOPED_SHARE_CONTEXT_LOCK(context);
5524 bool isCallValid =
5525 (context->skipValidation() ||
5526 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5527 context->getMutableErrorSetForValidation(),
5528 angle::EntryPoint::GLInsertEventMarkerEXT) &&
5529 ValidateInsertEventMarkerEXT(context, angle::EntryPoint::GLInsertEventMarkerEXT,
5530 length, marker)));
5531 if (isCallValid)
5532 {
5533 context->insertEventMarker(length, marker);
5534 }
5535 ANGLE_CAPTURE_GL(InsertEventMarkerEXT, isCallValid, context, length, marker);
5536 }
5537 else
5538 {
5539 GenerateContextLostErrorOnCurrentGlobalContext();
5540 }
5541 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5542 }
5543
GL_PopGroupMarkerEXT()5544 void GL_APIENTRY GL_PopGroupMarkerEXT()
5545 {
5546 Context *context = GetValidGlobalContext();
5547 // Don't run the EVENT() macro on the EXT_debug_marker entry points.
5548 // It can interfere with the debug events being set by the caller.
5549 // EVENT(context, GLPopGroupMarkerEXT, "context = %d", CID(context));
5550
5551 if (context)
5552 {
5553 SCOPED_SHARE_CONTEXT_LOCK(context);
5554 bool isCallValid =
5555 (context->skipValidation() ||
5556 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5557 context->getMutableErrorSetForValidation(),
5558 angle::EntryPoint::GLPopGroupMarkerEXT) &&
5559 ValidatePopGroupMarkerEXT(context, angle::EntryPoint::GLPopGroupMarkerEXT)));
5560 if (isCallValid)
5561 {
5562 context->popGroupMarker();
5563 }
5564 ANGLE_CAPTURE_GL(PopGroupMarkerEXT, isCallValid, context);
5565 }
5566 else
5567 {
5568 GenerateContextLostErrorOnCurrentGlobalContext();
5569 }
5570 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5571 }
5572
GL_PushGroupMarkerEXT(GLsizei length,const GLchar * marker)5573 void GL_APIENTRY GL_PushGroupMarkerEXT(GLsizei length, const GLchar *marker)
5574 {
5575 Context *context = GetValidGlobalContext();
5576 // Don't run the EVENT() macro on the EXT_debug_marker entry points.
5577 // It can interfere with the debug events being set by the caller.
5578 // EVENT(context, GLPushGroupMarkerEXT, "context = %d, length = %d, marker = 0x%016" PRIxPTR "",
5579 // CID(context), length, (uintptr_t)marker);
5580
5581 if (context)
5582 {
5583 SCOPED_SHARE_CONTEXT_LOCK(context);
5584 bool isCallValid =
5585 (context->skipValidation() ||
5586 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5587 context->getMutableErrorSetForValidation(),
5588 angle::EntryPoint::GLPushGroupMarkerEXT) &&
5589 ValidatePushGroupMarkerEXT(context, angle::EntryPoint::GLPushGroupMarkerEXT, length,
5590 marker)));
5591 if (isCallValid)
5592 {
5593 context->pushGroupMarker(length, marker);
5594 }
5595 ANGLE_CAPTURE_GL(PushGroupMarkerEXT, isCallValid, context, length, marker);
5596 }
5597 else
5598 {
5599 GenerateContextLostErrorOnCurrentGlobalContext();
5600 }
5601 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5602 }
5603
5604 // GL_EXT_depth_clamp
5605
5606 // GL_EXT_discard_framebuffer
GL_DiscardFramebufferEXT(GLenum target,GLsizei numAttachments,const GLenum * attachments)5607 void GL_APIENTRY GL_DiscardFramebufferEXT(GLenum target,
5608 GLsizei numAttachments,
5609 const GLenum *attachments)
5610 {
5611 Context *context = GetValidGlobalContext();
5612 EVENT(context, GLDiscardFramebufferEXT,
5613 "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR "",
5614 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), numAttachments,
5615 (uintptr_t)attachments);
5616
5617 if (context)
5618 {
5619 SCOPED_SHARE_CONTEXT_LOCK(context);
5620 bool isCallValid =
5621 (context->skipValidation() ||
5622 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5623 context->getMutableErrorSetForValidation(),
5624 angle::EntryPoint::GLDiscardFramebufferEXT) &&
5625 ValidateDiscardFramebufferEXT(context, angle::EntryPoint::GLDiscardFramebufferEXT,
5626 target, numAttachments, attachments)));
5627 if (isCallValid)
5628 {
5629 context->discardFramebuffer(target, numAttachments, attachments);
5630 }
5631 ANGLE_CAPTURE_GL(DiscardFramebufferEXT, isCallValid, context, target, numAttachments,
5632 attachments);
5633 }
5634 else
5635 {
5636 GenerateContextLostErrorOnCurrentGlobalContext();
5637 }
5638 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5639 }
5640
5641 // GL_EXT_disjoint_timer_query
GL_BeginQueryEXT(GLenum target,GLuint id)5642 void GL_APIENTRY GL_BeginQueryEXT(GLenum target, GLuint id)
5643 {
5644 Context *context = GetValidGlobalContext();
5645 EVENT(context, GLBeginQueryEXT, "context = %d, target = %s, id = %u", CID(context),
5646 GLenumToString(GLESEnum::QueryTarget, target), id);
5647
5648 if (context)
5649 {
5650 QueryType targetPacked = PackParam<QueryType>(target);
5651 QueryID idPacked = PackParam<QueryID>(id);
5652 SCOPED_SHARE_CONTEXT_LOCK(context);
5653 bool isCallValid =
5654 (context->skipValidation() ||
5655 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5656 context->getMutableErrorSetForValidation(),
5657 angle::EntryPoint::GLBeginQueryEXT) &&
5658 ValidateBeginQueryEXT(context, angle::EntryPoint::GLBeginQueryEXT, targetPacked,
5659 idPacked)));
5660 if (isCallValid)
5661 {
5662 context->beginQuery(targetPacked, idPacked);
5663 }
5664 ANGLE_CAPTURE_GL(BeginQueryEXT, isCallValid, context, targetPacked, idPacked);
5665 }
5666 else
5667 {
5668 GenerateContextLostErrorOnCurrentGlobalContext();
5669 }
5670 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5671 }
5672
GL_DeleteQueriesEXT(GLsizei n,const GLuint * ids)5673 void GL_APIENTRY GL_DeleteQueriesEXT(GLsizei n, const GLuint *ids)
5674 {
5675 Context *context = GetValidGlobalContext();
5676 EVENT(context, GLDeleteQueriesEXT, "context = %d, n = %d, ids = 0x%016" PRIxPTR "",
5677 CID(context), n, (uintptr_t)ids);
5678
5679 if (context)
5680 {
5681 const QueryID *idsPacked = PackParam<const QueryID *>(ids);
5682 SCOPED_SHARE_CONTEXT_LOCK(context);
5683 bool isCallValid = (context->skipValidation() ||
5684 ValidateDeleteQueriesEXT(context, angle::EntryPoint::GLDeleteQueriesEXT,
5685 n, idsPacked));
5686 if (isCallValid)
5687 {
5688 context->deleteQueries(n, idsPacked);
5689 }
5690 ANGLE_CAPTURE_GL(DeleteQueriesEXT, isCallValid, context, n, idsPacked);
5691 }
5692 else
5693 {
5694 GenerateContextLostErrorOnCurrentGlobalContext();
5695 }
5696 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5697 }
5698
GL_EndQueryEXT(GLenum target)5699 void GL_APIENTRY GL_EndQueryEXT(GLenum target)
5700 {
5701 Context *context = GetValidGlobalContext();
5702 EVENT(context, GLEndQueryEXT, "context = %d, target = %s", CID(context),
5703 GLenumToString(GLESEnum::QueryTarget, target));
5704
5705 if (context)
5706 {
5707 QueryType targetPacked = PackParam<QueryType>(target);
5708 SCOPED_SHARE_CONTEXT_LOCK(context);
5709 bool isCallValid =
5710 (context->skipValidation() ||
5711 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5712 context->getMutableErrorSetForValidation(),
5713 angle::EntryPoint::GLEndQueryEXT) &&
5714 ValidateEndQueryEXT(context, angle::EntryPoint::GLEndQueryEXT, targetPacked)));
5715 if (isCallValid)
5716 {
5717 context->endQuery(targetPacked);
5718 }
5719 ANGLE_CAPTURE_GL(EndQueryEXT, isCallValid, context, targetPacked);
5720 }
5721 else
5722 {
5723 GenerateContextLostErrorOnCurrentGlobalContext();
5724 }
5725 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5726 }
5727
GL_GenQueriesEXT(GLsizei n,GLuint * ids)5728 void GL_APIENTRY GL_GenQueriesEXT(GLsizei n, GLuint *ids)
5729 {
5730 Context *context = GetValidGlobalContext();
5731 EVENT(context, GLGenQueriesEXT, "context = %d, n = %d, ids = 0x%016" PRIxPTR "", CID(context),
5732 n, (uintptr_t)ids);
5733
5734 if (context)
5735 {
5736 QueryID *idsPacked = PackParam<QueryID *>(ids);
5737 SCOPED_SHARE_CONTEXT_LOCK(context);
5738 bool isCallValid =
5739 (context->skipValidation() ||
5740 ValidateGenQueriesEXT(context, angle::EntryPoint::GLGenQueriesEXT, n, idsPacked));
5741 if (isCallValid)
5742 {
5743 context->genQueries(n, idsPacked);
5744 }
5745 ANGLE_CAPTURE_GL(GenQueriesEXT, isCallValid, context, n, idsPacked);
5746 }
5747 else
5748 {
5749 GenerateContextLostErrorOnCurrentGlobalContext();
5750 }
5751 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5752 }
5753
GL_GetInteger64vEXT(GLenum pname,GLint64 * data)5754 void GL_APIENTRY GL_GetInteger64vEXT(GLenum pname, GLint64 *data)
5755 {
5756 Context *context = GetValidGlobalContext();
5757 EVENT(context, GLGetInteger64vEXT, "context = %d, pname = %s, data = 0x%016" PRIxPTR "",
5758 CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data);
5759
5760 if (context)
5761 {
5762 SCOPED_SHARE_CONTEXT_LOCK(context);
5763 bool isCallValid =
5764 (context->skipValidation() ||
5765 ValidateGetInteger64vEXT(context, angle::EntryPoint::GLGetInteger64vEXT, pname, data));
5766 if (isCallValid)
5767 {
5768 context->getInteger64v(pname, data);
5769 }
5770 ANGLE_CAPTURE_GL(GetInteger64vEXT, isCallValid, context, pname, data);
5771 }
5772 else
5773 {
5774 GenerateContextLostErrorOnCurrentGlobalContext();
5775 }
5776 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5777 }
5778
GL_GetQueryObjecti64vEXT(GLuint id,GLenum pname,GLint64 * params)5779 void GL_APIENTRY GL_GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
5780 {
5781 Context *context = GetGlobalContext();
5782 EVENT(context, GLGetQueryObjecti64vEXT,
5783 "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
5784 GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params);
5785
5786 if (context)
5787 {
5788 QueryID idPacked = PackParam<QueryID>(id);
5789 SCOPED_SHARE_CONTEXT_LOCK(context);
5790 bool isCallValid =
5791 (context->skipValidation() ||
5792 ValidateGetQueryObjecti64vEXT(context, angle::EntryPoint::GLGetQueryObjecti64vEXT,
5793 idPacked, pname, params));
5794 if (isCallValid)
5795 {
5796 context->getQueryObjecti64v(idPacked, pname, params);
5797 }
5798 ANGLE_CAPTURE_GL(GetQueryObjecti64vEXT, isCallValid, context, idPacked, pname, params);
5799 }
5800 else
5801 {
5802 }
5803 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5804 }
5805
GL_GetQueryObjectivEXT(GLuint id,GLenum pname,GLint * params)5806 void GL_APIENTRY GL_GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params)
5807 {
5808 Context *context = GetGlobalContext();
5809 EVENT(context, GLGetQueryObjectivEXT,
5810 "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
5811 GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params);
5812
5813 if (context)
5814 {
5815 QueryID idPacked = PackParam<QueryID>(id);
5816 SCOPED_SHARE_CONTEXT_LOCK(context);
5817 bool isCallValid =
5818 (context->skipValidation() ||
5819 ValidateGetQueryObjectivEXT(context, angle::EntryPoint::GLGetQueryObjectivEXT,
5820 idPacked, pname, params));
5821 if (isCallValid)
5822 {
5823 context->getQueryObjectiv(idPacked, pname, params);
5824 }
5825 ANGLE_CAPTURE_GL(GetQueryObjectivEXT, isCallValid, context, idPacked, pname, params);
5826 }
5827 else
5828 {
5829 }
5830 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5831 }
5832
GL_GetQueryObjectui64vEXT(GLuint id,GLenum pname,GLuint64 * params)5833 void GL_APIENTRY GL_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params)
5834 {
5835 Context *context = GetValidGlobalContext();
5836 EVENT(context, GLGetQueryObjectui64vEXT,
5837 "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
5838 GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params);
5839
5840 if (context)
5841 {
5842 QueryID idPacked = PackParam<QueryID>(id);
5843 SCOPED_SHARE_CONTEXT_LOCK(context);
5844 bool isCallValid =
5845 (context->skipValidation() ||
5846 ValidateGetQueryObjectui64vEXT(context, angle::EntryPoint::GLGetQueryObjectui64vEXT,
5847 idPacked, pname, params));
5848 if (isCallValid)
5849 {
5850 context->getQueryObjectui64v(idPacked, pname, params);
5851 }
5852 ANGLE_CAPTURE_GL(GetQueryObjectui64vEXT, isCallValid, context, idPacked, pname, params);
5853 }
5854 else
5855 {
5856 GenerateContextLostErrorOnCurrentGlobalContext();
5857 }
5858 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5859 }
5860
GL_GetQueryObjectuivEXT(GLuint id,GLenum pname,GLuint * params)5861 void GL_APIENTRY GL_GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
5862 {
5863 Context *context = GetValidGlobalContext();
5864 EVENT(context, GLGetQueryObjectuivEXT,
5865 "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
5866 GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params);
5867
5868 if (context)
5869 {
5870 QueryID idPacked = PackParam<QueryID>(id);
5871 SCOPED_SHARE_CONTEXT_LOCK(context);
5872 bool isCallValid =
5873 (context->skipValidation() ||
5874 ValidateGetQueryObjectuivEXT(context, angle::EntryPoint::GLGetQueryObjectuivEXT,
5875 idPacked, pname, params));
5876 if (isCallValid)
5877 {
5878 context->getQueryObjectuiv(idPacked, pname, params);
5879 }
5880 ANGLE_CAPTURE_GL(GetQueryObjectuivEXT, isCallValid, context, idPacked, pname, params);
5881 }
5882 else
5883 {
5884 GenerateContextLostErrorOnCurrentGlobalContext();
5885 }
5886 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5887 }
5888
GL_GetQueryivEXT(GLenum target,GLenum pname,GLint * params)5889 void GL_APIENTRY GL_GetQueryivEXT(GLenum target, GLenum pname, GLint *params)
5890 {
5891 Context *context = GetValidGlobalContext();
5892 EVENT(context, GLGetQueryivEXT,
5893 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
5894 GLenumToString(GLESEnum::QueryTarget, target),
5895 GLenumToString(GLESEnum::QueryParameterName, pname), (uintptr_t)params);
5896
5897 if (context)
5898 {
5899 QueryType targetPacked = PackParam<QueryType>(target);
5900 SCOPED_SHARE_CONTEXT_LOCK(context);
5901 bool isCallValid = (context->skipValidation() ||
5902 ValidateGetQueryivEXT(context, angle::EntryPoint::GLGetQueryivEXT,
5903 targetPacked, pname, params));
5904 if (isCallValid)
5905 {
5906 context->getQueryiv(targetPacked, pname, params);
5907 }
5908 ANGLE_CAPTURE_GL(GetQueryivEXT, isCallValid, context, targetPacked, pname, params);
5909 }
5910 else
5911 {
5912 GenerateContextLostErrorOnCurrentGlobalContext();
5913 }
5914 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5915 }
5916
GL_IsQueryEXT(GLuint id)5917 GLboolean GL_APIENTRY GL_IsQueryEXT(GLuint id)
5918 {
5919 Context *context = GetValidGlobalContext();
5920 EVENT(context, GLIsQueryEXT, "context = %d, id = %u", CID(context), id);
5921
5922 GLboolean returnValue;
5923 if (context)
5924 {
5925 QueryID idPacked = PackParam<QueryID>(id);
5926 SCOPED_SHARE_CONTEXT_LOCK(context);
5927 bool isCallValid = (context->skipValidation() ||
5928 ValidateIsQueryEXT(context, angle::EntryPoint::GLIsQueryEXT, idPacked));
5929 if (isCallValid)
5930 {
5931 returnValue = context->isQuery(idPacked);
5932 }
5933 else
5934 {
5935 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsQueryEXT, GLboolean>();
5936 }
5937 ANGLE_CAPTURE_GL(IsQueryEXT, isCallValid, context, idPacked, returnValue);
5938 }
5939 else
5940 {
5941 GenerateContextLostErrorOnCurrentGlobalContext();
5942 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsQueryEXT, GLboolean>();
5943 }
5944 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5945 return returnValue;
5946 }
5947
GL_QueryCounterEXT(GLuint id,GLenum target)5948 void GL_APIENTRY GL_QueryCounterEXT(GLuint id, GLenum target)
5949 {
5950 Context *context = GetValidGlobalContext();
5951 EVENT(context, GLQueryCounterEXT, "context = %d, id = %u, target = %s", CID(context), id,
5952 GLenumToString(GLESEnum::QueryCounterTarget, target));
5953
5954 if (context)
5955 {
5956 QueryID idPacked = PackParam<QueryID>(id);
5957 QueryType targetPacked = PackParam<QueryType>(target);
5958 SCOPED_SHARE_CONTEXT_LOCK(context);
5959 bool isCallValid =
5960 (context->skipValidation() ||
5961 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5962 context->getMutableErrorSetForValidation(),
5963 angle::EntryPoint::GLQueryCounterEXT) &&
5964 ValidateQueryCounterEXT(context, angle::EntryPoint::GLQueryCounterEXT, idPacked,
5965 targetPacked)));
5966 if (isCallValid)
5967 {
5968 context->queryCounter(idPacked, targetPacked);
5969 }
5970 ANGLE_CAPTURE_GL(QueryCounterEXT, isCallValid, context, idPacked, targetPacked);
5971 }
5972 else
5973 {
5974 GenerateContextLostErrorOnCurrentGlobalContext();
5975 }
5976 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
5977 }
5978
5979 // GL_EXT_draw_buffers
GL_DrawBuffersEXT(GLsizei n,const GLenum * bufs)5980 void GL_APIENTRY GL_DrawBuffersEXT(GLsizei n, const GLenum *bufs)
5981 {
5982 Context *context = GetValidGlobalContext();
5983 EVENT(context, GLDrawBuffersEXT, "context = %d, n = %d, bufs = 0x%016" PRIxPTR "", CID(context),
5984 n, (uintptr_t)bufs);
5985
5986 if (context)
5987 {
5988 SCOPED_SHARE_CONTEXT_LOCK(context);
5989 bool isCallValid =
5990 (context->skipValidation() ||
5991 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
5992 context->getMutableErrorSetForValidation(),
5993 angle::EntryPoint::GLDrawBuffersEXT) &&
5994 ValidateDrawBuffersEXT(context, angle::EntryPoint::GLDrawBuffersEXT, n, bufs)));
5995 if (isCallValid)
5996 {
5997 context->drawBuffers(n, bufs);
5998 }
5999 ANGLE_CAPTURE_GL(DrawBuffersEXT, isCallValid, context, n, bufs);
6000 }
6001 else
6002 {
6003 GenerateContextLostErrorOnCurrentGlobalContext();
6004 }
6005 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6006 }
6007
6008 // GL_EXT_draw_buffers_indexed
GL_BlendEquationSeparateiEXT(GLuint buf,GLenum modeRGB,GLenum modeAlpha)6009 void GL_APIENTRY GL_BlendEquationSeparateiEXT(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
6010 {
6011 Context *context = GetValidGlobalContext();
6012 EVENT(context, GLBlendEquationSeparateiEXT,
6013 "context = %d, buf = %u, modeRGB = %s, modeAlpha = %s", CID(context), buf,
6014 GLenumToString(GLESEnum::BlendEquationModeEXT, modeRGB),
6015 GLenumToString(GLESEnum::BlendEquationModeEXT, modeAlpha));
6016
6017 if (context)
6018 {
6019 bool isCallValid =
6020 (context->skipValidation() ||
6021 ValidateBlendEquationSeparateiEXT(
6022 context->getPrivateState(), context->getMutableErrorSetForValidation(),
6023 angle::EntryPoint::GLBlendEquationSeparateiEXT, buf, modeRGB, modeAlpha));
6024 if (isCallValid)
6025 {
6026 ContextPrivateBlendEquationSeparatei(context->getMutablePrivateState(),
6027 context->getMutablePrivateStateCache(), buf,
6028 modeRGB, modeAlpha);
6029 }
6030 ANGLE_CAPTURE_GL(BlendEquationSeparateiEXT, isCallValid, context, buf, modeRGB, modeAlpha);
6031 }
6032 else
6033 {
6034 GenerateContextLostErrorOnCurrentGlobalContext();
6035 }
6036 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6037 }
6038
GL_BlendEquationiEXT(GLuint buf,GLenum mode)6039 void GL_APIENTRY GL_BlendEquationiEXT(GLuint buf, GLenum mode)
6040 {
6041 Context *context = GetValidGlobalContext();
6042 EVENT(context, GLBlendEquationiEXT, "context = %d, buf = %u, mode = %s", CID(context), buf,
6043 GLenumToString(GLESEnum::BlendEquationModeEXT, mode));
6044
6045 if (context)
6046 {
6047 bool isCallValid =
6048 (context->skipValidation() ||
6049 ValidateBlendEquationiEXT(context->getPrivateState(),
6050 context->getMutableErrorSetForValidation(),
6051 angle::EntryPoint::GLBlendEquationiEXT, buf, mode));
6052 if (isCallValid)
6053 {
6054 ContextPrivateBlendEquationi(context->getMutablePrivateState(),
6055 context->getMutablePrivateStateCache(), buf, mode);
6056 }
6057 ANGLE_CAPTURE_GL(BlendEquationiEXT, isCallValid, context, buf, mode);
6058 }
6059 else
6060 {
6061 GenerateContextLostErrorOnCurrentGlobalContext();
6062 }
6063 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6064 }
6065
6066 void GL_APIENTRY
GL_BlendFuncSeparateiEXT(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)6067 GL_BlendFuncSeparateiEXT(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
6068 {
6069 Context *context = GetValidGlobalContext();
6070 EVENT(context, GLBlendFuncSeparateiEXT,
6071 "context = %d, buf = %u, srcRGB = %s, dstRGB = %s, srcAlpha = %s, dstAlpha = %s",
6072 CID(context), buf, GLenumToString(GLESEnum::BlendingFactor, srcRGB),
6073 GLenumToString(GLESEnum::BlendingFactor, dstRGB),
6074 GLenumToString(GLESEnum::BlendingFactor, srcAlpha),
6075 GLenumToString(GLESEnum::BlendingFactor, dstAlpha));
6076
6077 if (context)
6078 {
6079 bool isCallValid =
6080 (context->skipValidation() ||
6081 ValidateBlendFuncSeparateiEXT(context->getPrivateState(),
6082 context->getMutableErrorSetForValidation(),
6083 angle::EntryPoint::GLBlendFuncSeparateiEXT, buf, srcRGB,
6084 dstRGB, srcAlpha, dstAlpha));
6085 if (isCallValid)
6086 {
6087 ContextPrivateBlendFuncSeparatei(context->getMutablePrivateState(),
6088 context->getMutablePrivateStateCache(), buf, srcRGB,
6089 dstRGB, srcAlpha, dstAlpha);
6090 }
6091 ANGLE_CAPTURE_GL(BlendFuncSeparateiEXT, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
6092 dstAlpha);
6093 }
6094 else
6095 {
6096 GenerateContextLostErrorOnCurrentGlobalContext();
6097 }
6098 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6099 }
6100
GL_BlendFunciEXT(GLuint buf,GLenum src,GLenum dst)6101 void GL_APIENTRY GL_BlendFunciEXT(GLuint buf, GLenum src, GLenum dst)
6102 {
6103 Context *context = GetValidGlobalContext();
6104 EVENT(context, GLBlendFunciEXT, "context = %d, buf = %u, src = %s, dst = %s", CID(context), buf,
6105 GLenumToString(GLESEnum::BlendingFactor, src),
6106 GLenumToString(GLESEnum::BlendingFactor, dst));
6107
6108 if (context)
6109 {
6110 bool isCallValid =
6111 (context->skipValidation() ||
6112 ValidateBlendFunciEXT(context->getPrivateState(),
6113 context->getMutableErrorSetForValidation(),
6114 angle::EntryPoint::GLBlendFunciEXT, buf, src, dst));
6115 if (isCallValid)
6116 {
6117 ContextPrivateBlendFunci(context->getMutablePrivateState(),
6118 context->getMutablePrivateStateCache(), buf, src, dst);
6119 }
6120 ANGLE_CAPTURE_GL(BlendFunciEXT, isCallValid, context, buf, src, dst);
6121 }
6122 else
6123 {
6124 GenerateContextLostErrorOnCurrentGlobalContext();
6125 }
6126 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6127 }
6128
GL_ColorMaskiEXT(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)6129 void GL_APIENTRY GL_ColorMaskiEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
6130 {
6131 Context *context = GetValidGlobalContext();
6132 EVENT(context, GLColorMaskiEXT, "context = %d, index = %u, r = %s, g = %s, b = %s, a = %s",
6133 CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
6134 GLbooleanToString(a));
6135
6136 if (context)
6137 {
6138 bool isCallValid =
6139 (context->skipValidation() ||
6140 ValidateColorMaskiEXT(context->getPrivateState(),
6141 context->getMutableErrorSetForValidation(),
6142 angle::EntryPoint::GLColorMaskiEXT, index, r, g, b, a));
6143 if (isCallValid)
6144 {
6145 ContextPrivateColorMaski(context->getMutablePrivateState(),
6146 context->getMutablePrivateStateCache(), index, r, g, b, a);
6147 }
6148 ANGLE_CAPTURE_GL(ColorMaskiEXT, isCallValid, context, index, r, g, b, a);
6149 }
6150 else
6151 {
6152 GenerateContextLostErrorOnCurrentGlobalContext();
6153 }
6154 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6155 }
6156
GL_DisableiEXT(GLenum target,GLuint index)6157 void GL_APIENTRY GL_DisableiEXT(GLenum target, GLuint index)
6158 {
6159 Context *context = GetValidGlobalContext();
6160 EVENT(context, GLDisableiEXT, "context = %d, target = %s, index = %u", CID(context),
6161 GLenumToString(GLESEnum::EnableCap, target), index);
6162
6163 if (context)
6164 {
6165 bool isCallValid = (context->skipValidation() ||
6166 ValidateDisableiEXT(context->getPrivateState(),
6167 context->getMutableErrorSetForValidation(),
6168 angle::EntryPoint::GLDisableiEXT, target, index));
6169 if (isCallValid)
6170 {
6171 ContextPrivateDisablei(context->getMutablePrivateState(),
6172 context->getMutablePrivateStateCache(), target, index);
6173 }
6174 ANGLE_CAPTURE_GL(DisableiEXT, isCallValid, context, target, index);
6175 }
6176 else
6177 {
6178 GenerateContextLostErrorOnCurrentGlobalContext();
6179 }
6180 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6181 }
6182
GL_EnableiEXT(GLenum target,GLuint index)6183 void GL_APIENTRY GL_EnableiEXT(GLenum target, GLuint index)
6184 {
6185 Context *context = GetValidGlobalContext();
6186 EVENT(context, GLEnableiEXT, "context = %d, target = %s, index = %u", CID(context),
6187 GLenumToString(GLESEnum::EnableCap, target), index);
6188
6189 if (context)
6190 {
6191 bool isCallValid = (context->skipValidation() ||
6192 ValidateEnableiEXT(context->getPrivateState(),
6193 context->getMutableErrorSetForValidation(),
6194 angle::EntryPoint::GLEnableiEXT, target, index));
6195 if (isCallValid)
6196 {
6197 ContextPrivateEnablei(context->getMutablePrivateState(),
6198 context->getMutablePrivateStateCache(), target, index);
6199 }
6200 ANGLE_CAPTURE_GL(EnableiEXT, isCallValid, context, target, index);
6201 }
6202 else
6203 {
6204 GenerateContextLostErrorOnCurrentGlobalContext();
6205 }
6206 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6207 }
6208
GL_IsEnablediEXT(GLenum target,GLuint index)6209 GLboolean GL_APIENTRY GL_IsEnablediEXT(GLenum target, GLuint index)
6210 {
6211 Context *context = GetValidGlobalContext();
6212 EVENT(context, GLIsEnablediEXT, "context = %d, target = %s, index = %u", CID(context),
6213 GLenumToString(GLESEnum::EnableCap, target), index);
6214
6215 GLboolean returnValue;
6216 if (context)
6217 {
6218 bool isCallValid =
6219 (context->skipValidation() ||
6220 ValidateIsEnablediEXT(context->getPrivateState(),
6221 context->getMutableErrorSetForValidation(),
6222 angle::EntryPoint::GLIsEnablediEXT, target, index));
6223 if (isCallValid)
6224 {
6225 returnValue =
6226 ContextPrivateIsEnabledi(context->getMutablePrivateState(),
6227 context->getMutablePrivateStateCache(), target, index);
6228 }
6229 else
6230 {
6231 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediEXT, GLboolean>();
6232 }
6233 ANGLE_CAPTURE_GL(IsEnablediEXT, isCallValid, context, target, index, returnValue);
6234 }
6235 else
6236 {
6237 GenerateContextLostErrorOnCurrentGlobalContext();
6238 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediEXT, GLboolean>();
6239 }
6240 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6241 return returnValue;
6242 }
6243
6244 // GL_EXT_draw_elements_base_vertex
GL_DrawElementsBaseVertexEXT(GLenum mode,GLsizei count,GLenum type,const void * indices,GLint basevertex)6245 void GL_APIENTRY GL_DrawElementsBaseVertexEXT(GLenum mode,
6246 GLsizei count,
6247 GLenum type,
6248 const void *indices,
6249 GLint basevertex)
6250 {
6251 Context *context = GetValidGlobalContext();
6252 EVENT(context, GLDrawElementsBaseVertexEXT,
6253 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
6254 ", basevertex = %d",
6255 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count,
6256 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, basevertex);
6257
6258 if (context)
6259 {
6260 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
6261 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
6262 SCOPED_SHARE_CONTEXT_LOCK(context);
6263 bool isCallValid = (context->skipValidation() ||
6264 ValidateDrawElementsBaseVertexEXT(
6265 context, angle::EntryPoint::GLDrawElementsBaseVertexEXT, modePacked,
6266 count, typePacked, indices, basevertex));
6267 if (isCallValid)
6268 {
6269 context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex);
6270 }
6271 ANGLE_CAPTURE_GL(DrawElementsBaseVertexEXT, isCallValid, context, modePacked, count,
6272 typePacked, indices, basevertex);
6273 }
6274 else
6275 {
6276 GenerateContextLostErrorOnCurrentGlobalContext();
6277 }
6278 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6279 }
6280
GL_DrawElementsInstancedBaseVertexEXT(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount,GLint basevertex)6281 void GL_APIENTRY GL_DrawElementsInstancedBaseVertexEXT(GLenum mode,
6282 GLsizei count,
6283 GLenum type,
6284 const void *indices,
6285 GLsizei instancecount,
6286 GLint basevertex)
6287 {
6288 Context *context = GetValidGlobalContext();
6289 EVENT(context, GLDrawElementsInstancedBaseVertexEXT,
6290 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
6291 ", instancecount = %d, basevertex = %d",
6292 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count,
6293 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instancecount,
6294 basevertex);
6295
6296 if (context)
6297 {
6298 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
6299 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
6300 SCOPED_SHARE_CONTEXT_LOCK(context);
6301 bool isCallValid = (context->skipValidation() ||
6302 ValidateDrawElementsInstancedBaseVertexEXT(
6303 context, angle::EntryPoint::GLDrawElementsInstancedBaseVertexEXT,
6304 modePacked, count, typePacked, indices, instancecount, basevertex));
6305 if (isCallValid)
6306 {
6307 context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices,
6308 instancecount, basevertex);
6309 }
6310 ANGLE_CAPTURE_GL(DrawElementsInstancedBaseVertexEXT, isCallValid, context, modePacked,
6311 count, typePacked, indices, instancecount, basevertex);
6312 }
6313 else
6314 {
6315 GenerateContextLostErrorOnCurrentGlobalContext();
6316 }
6317 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6318 }
6319
GL_DrawRangeElementsBaseVertexEXT(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices,GLint basevertex)6320 void GL_APIENTRY GL_DrawRangeElementsBaseVertexEXT(GLenum mode,
6321 GLuint start,
6322 GLuint end,
6323 GLsizei count,
6324 GLenum type,
6325 const void *indices,
6326 GLint basevertex)
6327 {
6328 Context *context = GetValidGlobalContext();
6329 EVENT(context, GLDrawRangeElementsBaseVertexEXT,
6330 "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = "
6331 "0x%016" PRIxPTR ", basevertex = %d",
6332 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), start, end, count,
6333 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, basevertex);
6334
6335 if (context)
6336 {
6337 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
6338 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
6339 SCOPED_SHARE_CONTEXT_LOCK(context);
6340 bool isCallValid = (context->skipValidation() ||
6341 ValidateDrawRangeElementsBaseVertexEXT(
6342 context, angle::EntryPoint::GLDrawRangeElementsBaseVertexEXT,
6343 modePacked, start, end, count, typePacked, indices, basevertex));
6344 if (isCallValid)
6345 {
6346 context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices,
6347 basevertex);
6348 }
6349 ANGLE_CAPTURE_GL(DrawRangeElementsBaseVertexEXT, isCallValid, context, modePacked, start,
6350 end, count, typePacked, indices, basevertex);
6351 }
6352 else
6353 {
6354 GenerateContextLostErrorOnCurrentGlobalContext();
6355 }
6356 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6357 }
6358
GL_MultiDrawElementsBaseVertexEXT(GLenum mode,const GLsizei * count,GLenum type,const void * const * indices,GLsizei drawcount,const GLint * basevertex)6359 void GL_APIENTRY GL_MultiDrawElementsBaseVertexEXT(GLenum mode,
6360 const GLsizei *count,
6361 GLenum type,
6362 const void *const *indices,
6363 GLsizei drawcount,
6364 const GLint *basevertex)
6365 {
6366 Context *context = GetValidGlobalContext();
6367 EVENT(context, GLMultiDrawElementsBaseVertexEXT,
6368 "context = %d, mode = %s, count = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
6369 ", drawcount = %d, basevertex = 0x%016" PRIxPTR "",
6370 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)count,
6371 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, drawcount,
6372 (uintptr_t)basevertex);
6373
6374 if (context)
6375 {
6376 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
6377 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
6378 SCOPED_SHARE_CONTEXT_LOCK(context);
6379 bool isCallValid =
6380 (context->skipValidation() ||
6381 (ValidatePixelLocalStorageInactive(
6382 context->getPrivateState(), context->getMutableErrorSetForValidation(),
6383 angle::EntryPoint::GLMultiDrawElementsBaseVertexEXT) &&
6384 ValidateMultiDrawElementsBaseVertexEXT(
6385 context, angle::EntryPoint::GLMultiDrawElementsBaseVertexEXT, modePacked, count,
6386 typePacked, indices, drawcount, basevertex)));
6387 if (isCallValid)
6388 {
6389 context->multiDrawElementsBaseVertex(modePacked, count, typePacked, indices, drawcount,
6390 basevertex);
6391 }
6392 ANGLE_CAPTURE_GL(MultiDrawElementsBaseVertexEXT, isCallValid, context, modePacked, count,
6393 typePacked, indices, drawcount, basevertex);
6394 }
6395 else
6396 {
6397 GenerateContextLostErrorOnCurrentGlobalContext();
6398 }
6399 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6400 }
6401
6402 // GL_EXT_external_buffer
GL_BufferStorageExternalEXT(GLenum target,GLintptr offset,GLsizeiptr size,GLeglClientBufferEXT clientBuffer,GLbitfield flags)6403 void GL_APIENTRY GL_BufferStorageExternalEXT(GLenum target,
6404 GLintptr offset,
6405 GLsizeiptr size,
6406 GLeglClientBufferEXT clientBuffer,
6407 GLbitfield flags)
6408 {
6409 Context *context = GetValidGlobalContext();
6410 EVENT(context, GLBufferStorageExternalEXT,
6411 "context = %d, target = %s, offset = %llu, size = %llu, clientBuffer = 0x%016" PRIxPTR
6412 ", flags = %s",
6413 CID(context), GLenumToString(GLESEnum::AllEnums, target),
6414 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size),
6415 (uintptr_t)clientBuffer, GLbitfieldToString(GLESEnum::BufferStorageMask, flags).c_str());
6416
6417 if (context)
6418 {
6419 BufferBinding targetPacked = PackParam<BufferBinding>(target);
6420 SCOPED_SHARE_CONTEXT_LOCK(context);
6421 bool isCallValid =
6422 (context->skipValidation() ||
6423 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6424 context->getMutableErrorSetForValidation(),
6425 angle::EntryPoint::GLBufferStorageExternalEXT) &&
6426 ValidateBufferStorageExternalEXT(context,
6427 angle::EntryPoint::GLBufferStorageExternalEXT,
6428 targetPacked, offset, size, clientBuffer, flags)));
6429 if (isCallValid)
6430 {
6431 context->bufferStorageExternal(targetPacked, offset, size, clientBuffer, flags);
6432 }
6433 ANGLE_CAPTURE_GL(BufferStorageExternalEXT, isCallValid, context, targetPacked, offset, size,
6434 clientBuffer, flags);
6435 }
6436 else
6437 {
6438 GenerateContextLostErrorOnCurrentGlobalContext();
6439 }
6440 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6441 }
6442
GL_NamedBufferStorageExternalEXT(GLuint buffer,GLintptr offset,GLsizeiptr size,GLeglClientBufferEXT clientBuffer,GLbitfield flags)6443 void GL_APIENTRY GL_NamedBufferStorageExternalEXT(GLuint buffer,
6444 GLintptr offset,
6445 GLsizeiptr size,
6446 GLeglClientBufferEXT clientBuffer,
6447 GLbitfield flags)
6448 {
6449 Context *context = GetValidGlobalContext();
6450 EVENT(context, GLNamedBufferStorageExternalEXT,
6451 "context = %d, buffer = %u, offset = %llu, size = %llu, clientBuffer = 0x%016" PRIxPTR
6452 ", flags = %s",
6453 CID(context), buffer, static_cast<unsigned long long>(offset),
6454 static_cast<unsigned long long>(size), (uintptr_t)clientBuffer,
6455 GLbitfieldToString(GLESEnum::BufferStorageMask, flags).c_str());
6456
6457 if (context)
6458 {
6459 SCOPED_SHARE_CONTEXT_LOCK(context);
6460 bool isCallValid =
6461 (context->skipValidation() ||
6462 (ValidatePixelLocalStorageInactive(
6463 context->getPrivateState(), context->getMutableErrorSetForValidation(),
6464 angle::EntryPoint::GLNamedBufferStorageExternalEXT) &&
6465 ValidateNamedBufferStorageExternalEXT(
6466 context, angle::EntryPoint::GLNamedBufferStorageExternalEXT, buffer, offset, size,
6467 clientBuffer, flags)));
6468 if (isCallValid)
6469 {
6470 context->namedBufferStorageExternal(buffer, offset, size, clientBuffer, flags);
6471 }
6472 ANGLE_CAPTURE_GL(NamedBufferStorageExternalEXT, isCallValid, context, buffer, offset, size,
6473 clientBuffer, flags);
6474 }
6475 else
6476 {
6477 GenerateContextLostErrorOnCurrentGlobalContext();
6478 }
6479 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6480 }
6481
6482 // GL_EXT_float_blend
6483
6484 // GL_EXT_geometry_shader
GL_FramebufferTextureEXT(GLenum target,GLenum attachment,GLuint texture,GLint level)6485 void GL_APIENTRY GL_FramebufferTextureEXT(GLenum target,
6486 GLenum attachment,
6487 GLuint texture,
6488 GLint level)
6489 {
6490 Context *context = GetValidGlobalContext();
6491 EVENT(context, GLFramebufferTextureEXT,
6492 "context = %d, target = %s, attachment = %s, texture = %u, level = %d", CID(context),
6493 GLenumToString(GLESEnum::FramebufferTarget, target),
6494 GLenumToString(GLESEnum::FramebufferAttachment, attachment), texture, level);
6495
6496 if (context)
6497 {
6498 TextureID texturePacked = PackParam<TextureID>(texture);
6499 SCOPED_SHARE_CONTEXT_LOCK(context);
6500 bool isCallValid =
6501 (context->skipValidation() ||
6502 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6503 context->getMutableErrorSetForValidation(),
6504 angle::EntryPoint::GLFramebufferTextureEXT) &&
6505 ValidateFramebufferTextureEXT(context, angle::EntryPoint::GLFramebufferTextureEXT,
6506 target, attachment, texturePacked, level)));
6507 if (isCallValid)
6508 {
6509 context->framebufferTexture(target, attachment, texturePacked, level);
6510 }
6511 ANGLE_CAPTURE_GL(FramebufferTextureEXT, isCallValid, context, target, attachment,
6512 texturePacked, level);
6513 }
6514 else
6515 {
6516 GenerateContextLostErrorOnCurrentGlobalContext();
6517 }
6518 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6519 }
6520
6521 // GL_EXT_gpu_shader5
6522
6523 // GL_EXT_instanced_arrays
GL_DrawArraysInstancedEXT(GLenum mode,GLint start,GLsizei count,GLsizei primcount)6524 void GL_APIENTRY GL_DrawArraysInstancedEXT(GLenum mode,
6525 GLint start,
6526 GLsizei count,
6527 GLsizei primcount)
6528 {
6529 Context *context = GetValidGlobalContext();
6530 EVENT(context, GLDrawArraysInstancedEXT,
6531 "context = %d, mode = %s, start = %d, count = %d, primcount = %d", CID(context),
6532 GLenumToString(GLESEnum::PrimitiveType, mode), start, count, primcount);
6533
6534 if (context)
6535 {
6536 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
6537 SCOPED_SHARE_CONTEXT_LOCK(context);
6538 bool isCallValid =
6539 (context->skipValidation() ||
6540 ValidateDrawArraysInstancedEXT(context, angle::EntryPoint::GLDrawArraysInstancedEXT,
6541 modePacked, start, count, primcount));
6542 if (isCallValid)
6543 {
6544 context->drawArraysInstanced(modePacked, start, count, primcount);
6545 }
6546 ANGLE_CAPTURE_GL(DrawArraysInstancedEXT, isCallValid, context, modePacked, start, count,
6547 primcount);
6548 }
6549 else
6550 {
6551 GenerateContextLostErrorOnCurrentGlobalContext();
6552 }
6553 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6554 }
6555
GL_DrawElementsInstancedEXT(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei primcount)6556 void GL_APIENTRY GL_DrawElementsInstancedEXT(GLenum mode,
6557 GLsizei count,
6558 GLenum type,
6559 const void *indices,
6560 GLsizei primcount)
6561 {
6562 Context *context = GetValidGlobalContext();
6563 EVENT(context, GLDrawElementsInstancedEXT,
6564 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
6565 ", primcount = %d",
6566 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count,
6567 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, primcount);
6568
6569 if (context)
6570 {
6571 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
6572 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
6573 SCOPED_SHARE_CONTEXT_LOCK(context);
6574 bool isCallValid = (context->skipValidation() ||
6575 ValidateDrawElementsInstancedEXT(
6576 context, angle::EntryPoint::GLDrawElementsInstancedEXT, modePacked,
6577 count, typePacked, indices, primcount));
6578 if (isCallValid)
6579 {
6580 context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
6581 }
6582 ANGLE_CAPTURE_GL(DrawElementsInstancedEXT, isCallValid, context, modePacked, count,
6583 typePacked, indices, primcount);
6584 }
6585 else
6586 {
6587 GenerateContextLostErrorOnCurrentGlobalContext();
6588 }
6589 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6590 }
6591
GL_VertexAttribDivisorEXT(GLuint index,GLuint divisor)6592 void GL_APIENTRY GL_VertexAttribDivisorEXT(GLuint index, GLuint divisor)
6593 {
6594 Context *context = GetValidGlobalContext();
6595 EVENT(context, GLVertexAttribDivisorEXT, "context = %d, index = %u, divisor = %u", CID(context),
6596 index, divisor);
6597
6598 if (context)
6599 {
6600 SCOPED_SHARE_CONTEXT_LOCK(context);
6601 bool isCallValid =
6602 (context->skipValidation() ||
6603 ValidateVertexAttribDivisorEXT(context, angle::EntryPoint::GLVertexAttribDivisorEXT,
6604 index, divisor));
6605 if (isCallValid)
6606 {
6607 context->vertexAttribDivisor(index, divisor);
6608 }
6609 ANGLE_CAPTURE_GL(VertexAttribDivisorEXT, isCallValid, context, index, divisor);
6610 }
6611 else
6612 {
6613 GenerateContextLostErrorOnCurrentGlobalContext();
6614 }
6615 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6616 }
6617
6618 // GL_EXT_map_buffer_range
GL_FlushMappedBufferRangeEXT(GLenum target,GLintptr offset,GLsizeiptr length)6619 void GL_APIENTRY GL_FlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length)
6620 {
6621 Context *context = GetValidGlobalContext();
6622 EVENT(context, GLFlushMappedBufferRangeEXT,
6623 "context = %d, target = %s, offset = %llu, length = %llu", CID(context),
6624 GLenumToString(GLESEnum::BufferTargetARB, target),
6625 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length));
6626
6627 if (context)
6628 {
6629 BufferBinding targetPacked = PackParam<BufferBinding>(target);
6630 SCOPED_SHARE_CONTEXT_LOCK(context);
6631 bool isCallValid =
6632 (context->skipValidation() ||
6633 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6634 context->getMutableErrorSetForValidation(),
6635 angle::EntryPoint::GLFlushMappedBufferRangeEXT) &&
6636 ValidateFlushMappedBufferRangeEXT(context,
6637 angle::EntryPoint::GLFlushMappedBufferRangeEXT,
6638 targetPacked, offset, length)));
6639 if (isCallValid)
6640 {
6641 context->flushMappedBufferRange(targetPacked, offset, length);
6642 }
6643 ANGLE_CAPTURE_GL(FlushMappedBufferRangeEXT, isCallValid, context, targetPacked, offset,
6644 length);
6645 }
6646 else
6647 {
6648 GenerateContextLostErrorOnCurrentGlobalContext();
6649 }
6650 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6651 }
6652
GL_MapBufferRangeEXT(GLenum target,GLintptr offset,GLsizeiptr length,GLbitfield access)6653 void *GL_APIENTRY GL_MapBufferRangeEXT(GLenum target,
6654 GLintptr offset,
6655 GLsizeiptr length,
6656 GLbitfield access)
6657 {
6658 Context *context = GetValidGlobalContext();
6659 EVENT(context, GLMapBufferRangeEXT,
6660 "context = %d, target = %s, offset = %llu, length = %llu, access = %s", CID(context),
6661 GLenumToString(GLESEnum::BufferTargetARB, target),
6662 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length),
6663 GLbitfieldToString(GLESEnum::MapBufferAccessMask, access).c_str());
6664
6665 void *returnValue;
6666 if (context)
6667 {
6668 BufferBinding targetPacked = PackParam<BufferBinding>(target);
6669 SCOPED_SHARE_CONTEXT_LOCK(context);
6670 bool isCallValid =
6671 (context->skipValidation() ||
6672 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6673 context->getMutableErrorSetForValidation(),
6674 angle::EntryPoint::GLMapBufferRangeEXT) &&
6675 ValidateMapBufferRangeEXT(context, angle::EntryPoint::GLMapBufferRangeEXT,
6676 targetPacked, offset, length, access)));
6677 if (isCallValid)
6678 {
6679 returnValue = context->mapBufferRange(targetPacked, offset, length, access);
6680 }
6681 else
6682 {
6683 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferRangeEXT, void *>();
6684 }
6685 ANGLE_CAPTURE_GL(MapBufferRangeEXT, isCallValid, context, targetPacked, offset, length,
6686 access, returnValue);
6687 }
6688 else
6689 {
6690 GenerateContextLostErrorOnCurrentGlobalContext();
6691 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferRangeEXT, void *>();
6692 }
6693 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6694 return returnValue;
6695 }
6696
6697 // GL_EXT_memory_object
GL_BufferStorageMemEXT(GLenum target,GLsizeiptr size,GLuint memory,GLuint64 offset)6698 void GL_APIENTRY GL_BufferStorageMemEXT(GLenum target,
6699 GLsizeiptr size,
6700 GLuint memory,
6701 GLuint64 offset)
6702 {
6703 Context *context = GetValidGlobalContext();
6704 EVENT(context, GLBufferStorageMemEXT,
6705 "context = %d, target = %s, size = %llu, memory = %u, offset = %llu", CID(context),
6706 GLenumToString(GLESEnum::BufferTargetARB, target), static_cast<unsigned long long>(size),
6707 memory, static_cast<unsigned long long>(offset));
6708
6709 if (context)
6710 {
6711 TextureType targetPacked = PackParam<TextureType>(target);
6712 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
6713 SCOPED_SHARE_CONTEXT_LOCK(context);
6714 bool isCallValid =
6715 (context->skipValidation() ||
6716 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6717 context->getMutableErrorSetForValidation(),
6718 angle::EntryPoint::GLBufferStorageMemEXT) &&
6719 ValidateBufferStorageMemEXT(context, angle::EntryPoint::GLBufferStorageMemEXT,
6720 targetPacked, size, memoryPacked, offset)));
6721 if (isCallValid)
6722 {
6723 context->bufferStorageMem(targetPacked, size, memoryPacked, offset);
6724 }
6725 ANGLE_CAPTURE_GL(BufferStorageMemEXT, isCallValid, context, targetPacked, size,
6726 memoryPacked, offset);
6727 }
6728 else
6729 {
6730 GenerateContextLostErrorOnCurrentGlobalContext();
6731 }
6732 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6733 }
6734
GL_CreateMemoryObjectsEXT(GLsizei n,GLuint * memoryObjects)6735 void GL_APIENTRY GL_CreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects)
6736 {
6737 Context *context = GetValidGlobalContext();
6738 EVENT(context, GLCreateMemoryObjectsEXT,
6739 "context = %d, n = %d, memoryObjects = 0x%016" PRIxPTR "", CID(context), n,
6740 (uintptr_t)memoryObjects);
6741
6742 if (context)
6743 {
6744 MemoryObjectID *memoryObjectsPacked = PackParam<MemoryObjectID *>(memoryObjects);
6745 SCOPED_SHARE_CONTEXT_LOCK(context);
6746 bool isCallValid =
6747 (context->skipValidation() ||
6748 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6749 context->getMutableErrorSetForValidation(),
6750 angle::EntryPoint::GLCreateMemoryObjectsEXT) &&
6751 ValidateCreateMemoryObjectsEXT(context, angle::EntryPoint::GLCreateMemoryObjectsEXT,
6752 n, memoryObjectsPacked)));
6753 if (isCallValid)
6754 {
6755 context->createMemoryObjects(n, memoryObjectsPacked);
6756 }
6757 ANGLE_CAPTURE_GL(CreateMemoryObjectsEXT, isCallValid, context, n, memoryObjectsPacked);
6758 }
6759 else
6760 {
6761 GenerateContextLostErrorOnCurrentGlobalContext();
6762 }
6763 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6764 }
6765
GL_DeleteMemoryObjectsEXT(GLsizei n,const GLuint * memoryObjects)6766 void GL_APIENTRY GL_DeleteMemoryObjectsEXT(GLsizei n, const GLuint *memoryObjects)
6767 {
6768 Context *context = GetValidGlobalContext();
6769 EVENT(context, GLDeleteMemoryObjectsEXT,
6770 "context = %d, n = %d, memoryObjects = 0x%016" PRIxPTR "", CID(context), n,
6771 (uintptr_t)memoryObjects);
6772
6773 if (context)
6774 {
6775 const MemoryObjectID *memoryObjectsPacked =
6776 PackParam<const MemoryObjectID *>(memoryObjects);
6777 SCOPED_SHARE_CONTEXT_LOCK(context);
6778 bool isCallValid =
6779 (context->skipValidation() ||
6780 ValidateDeleteMemoryObjectsEXT(context, angle::EntryPoint::GLDeleteMemoryObjectsEXT, n,
6781 memoryObjectsPacked));
6782 if (isCallValid)
6783 {
6784 context->deleteMemoryObjects(n, memoryObjectsPacked);
6785 }
6786 ANGLE_CAPTURE_GL(DeleteMemoryObjectsEXT, isCallValid, context, n, memoryObjectsPacked);
6787 }
6788 else
6789 {
6790 GenerateContextLostErrorOnCurrentGlobalContext();
6791 }
6792 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6793 }
6794
GL_GetMemoryObjectParameterivEXT(GLuint memoryObject,GLenum pname,GLint * params)6795 void GL_APIENTRY GL_GetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, GLint *params)
6796 {
6797 Context *context = GetValidGlobalContext();
6798 EVENT(context, GLGetMemoryObjectParameterivEXT,
6799 "context = %d, memoryObject = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
6800 memoryObject, GLenumToString(GLESEnum::MemoryObjectParameterName, pname),
6801 (uintptr_t)params);
6802
6803 if (context)
6804 {
6805 MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject);
6806 SCOPED_SHARE_CONTEXT_LOCK(context);
6807 bool isCallValid = (context->skipValidation() ||
6808 ValidateGetMemoryObjectParameterivEXT(
6809 context, angle::EntryPoint::GLGetMemoryObjectParameterivEXT,
6810 memoryObjectPacked, pname, params));
6811 if (isCallValid)
6812 {
6813 context->getMemoryObjectParameteriv(memoryObjectPacked, pname, params);
6814 }
6815 ANGLE_CAPTURE_GL(GetMemoryObjectParameterivEXT, isCallValid, context, memoryObjectPacked,
6816 pname, params);
6817 }
6818 else
6819 {
6820 GenerateContextLostErrorOnCurrentGlobalContext();
6821 }
6822 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6823 }
6824
GL_GetUnsignedBytevEXT(GLenum pname,GLubyte * data)6825 void GL_APIENTRY GL_GetUnsignedBytevEXT(GLenum pname, GLubyte *data)
6826 {
6827 Context *context = GetValidGlobalContext();
6828 EVENT(context, GLGetUnsignedBytevEXT, "context = %d, pname = %s, data = 0x%016" PRIxPTR "",
6829 CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data);
6830
6831 if (context)
6832 {
6833 SCOPED_SHARE_CONTEXT_LOCK(context);
6834 bool isCallValid = (context->skipValidation() ||
6835 ValidateGetUnsignedBytevEXT(
6836 context, angle::EntryPoint::GLGetUnsignedBytevEXT, pname, data));
6837 if (isCallValid)
6838 {
6839 context->getUnsignedBytev(pname, data);
6840 }
6841 ANGLE_CAPTURE_GL(GetUnsignedBytevEXT, isCallValid, context, pname, data);
6842 }
6843 else
6844 {
6845 GenerateContextLostErrorOnCurrentGlobalContext();
6846 }
6847 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6848 }
6849
GL_GetUnsignedBytei_vEXT(GLenum target,GLuint index,GLubyte * data)6850 void GL_APIENTRY GL_GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data)
6851 {
6852 Context *context = GetValidGlobalContext();
6853 EVENT(context, GLGetUnsignedBytei_vEXT,
6854 "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context),
6855 GLenumToString(GLESEnum::AllEnums, target), index, (uintptr_t)data);
6856
6857 if (context)
6858 {
6859 SCOPED_SHARE_CONTEXT_LOCK(context);
6860 bool isCallValid =
6861 (context->skipValidation() ||
6862 ValidateGetUnsignedBytei_vEXT(context, angle::EntryPoint::GLGetUnsignedBytei_vEXT,
6863 target, index, data));
6864 if (isCallValid)
6865 {
6866 context->getUnsignedBytei_v(target, index, data);
6867 }
6868 ANGLE_CAPTURE_GL(GetUnsignedBytei_vEXT, isCallValid, context, target, index, data);
6869 }
6870 else
6871 {
6872 GenerateContextLostErrorOnCurrentGlobalContext();
6873 }
6874 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6875 }
6876
GL_IsMemoryObjectEXT(GLuint memoryObject)6877 GLboolean GL_APIENTRY GL_IsMemoryObjectEXT(GLuint memoryObject)
6878 {
6879 Context *context = GetValidGlobalContext();
6880 EVENT(context, GLIsMemoryObjectEXT, "context = %d, memoryObject = %u", CID(context),
6881 memoryObject);
6882
6883 GLboolean returnValue;
6884 if (context)
6885 {
6886 MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject);
6887 SCOPED_SHARE_CONTEXT_LOCK(context);
6888 bool isCallValid =
6889 (context->skipValidation() ||
6890 ValidateIsMemoryObjectEXT(context, angle::EntryPoint::GLIsMemoryObjectEXT,
6891 memoryObjectPacked));
6892 if (isCallValid)
6893 {
6894 returnValue = context->isMemoryObject(memoryObjectPacked);
6895 }
6896 else
6897 {
6898 returnValue =
6899 GetDefaultReturnValue<angle::EntryPoint::GLIsMemoryObjectEXT, GLboolean>();
6900 }
6901 ANGLE_CAPTURE_GL(IsMemoryObjectEXT, isCallValid, context, memoryObjectPacked, returnValue);
6902 }
6903 else
6904 {
6905 GenerateContextLostErrorOnCurrentGlobalContext();
6906 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsMemoryObjectEXT, GLboolean>();
6907 }
6908 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6909 return returnValue;
6910 }
6911
GL_MemoryObjectParameterivEXT(GLuint memoryObject,GLenum pname,const GLint * params)6912 void GL_APIENTRY GL_MemoryObjectParameterivEXT(GLuint memoryObject,
6913 GLenum pname,
6914 const GLint *params)
6915 {
6916 Context *context = GetValidGlobalContext();
6917 EVENT(context, GLMemoryObjectParameterivEXT,
6918 "context = %d, memoryObject = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
6919 memoryObject, GLenumToString(GLESEnum::MemoryObjectParameterName, pname),
6920 (uintptr_t)params);
6921
6922 if (context)
6923 {
6924 MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject);
6925 SCOPED_SHARE_CONTEXT_LOCK(context);
6926 bool isCallValid =
6927 (context->skipValidation() ||
6928 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6929 context->getMutableErrorSetForValidation(),
6930 angle::EntryPoint::GLMemoryObjectParameterivEXT) &&
6931 ValidateMemoryObjectParameterivEXT(context,
6932 angle::EntryPoint::GLMemoryObjectParameterivEXT,
6933 memoryObjectPacked, pname, params)));
6934 if (isCallValid)
6935 {
6936 context->memoryObjectParameteriv(memoryObjectPacked, pname, params);
6937 }
6938 ANGLE_CAPTURE_GL(MemoryObjectParameterivEXT, isCallValid, context, memoryObjectPacked,
6939 pname, params);
6940 }
6941 else
6942 {
6943 GenerateContextLostErrorOnCurrentGlobalContext();
6944 }
6945 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6946 }
6947
GL_TexStorageMem2DEXT(GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLuint memory,GLuint64 offset)6948 void GL_APIENTRY GL_TexStorageMem2DEXT(GLenum target,
6949 GLsizei levels,
6950 GLenum internalFormat,
6951 GLsizei width,
6952 GLsizei height,
6953 GLuint memory,
6954 GLuint64 offset)
6955 {
6956 Context *context = GetValidGlobalContext();
6957 EVENT(context, GLTexStorageMem2DEXT,
6958 "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, "
6959 "memory = %u, offset = %llu",
6960 CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels,
6961 GLenumToString(GLESEnum::SizedInternalFormat, internalFormat), width, height, memory,
6962 static_cast<unsigned long long>(offset));
6963
6964 if (context)
6965 {
6966 TextureType targetPacked = PackParam<TextureType>(target);
6967 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
6968 SCOPED_SHARE_CONTEXT_LOCK(context);
6969 bool isCallValid =
6970 (context->skipValidation() ||
6971 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
6972 context->getMutableErrorSetForValidation(),
6973 angle::EntryPoint::GLTexStorageMem2DEXT) &&
6974 ValidateTexStorageMem2DEXT(context, angle::EntryPoint::GLTexStorageMem2DEXT,
6975 targetPacked, levels, internalFormat, width, height,
6976 memoryPacked, offset)));
6977 if (isCallValid)
6978 {
6979 context->texStorageMem2D(targetPacked, levels, internalFormat, width, height,
6980 memoryPacked, offset);
6981 }
6982 ANGLE_CAPTURE_GL(TexStorageMem2DEXT, isCallValid, context, targetPacked, levels,
6983 internalFormat, width, height, memoryPacked, offset);
6984 }
6985 else
6986 {
6987 GenerateContextLostErrorOnCurrentGlobalContext();
6988 }
6989 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
6990 }
6991
GL_TexStorageMem2DMultisampleEXT(GLenum target,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset)6992 void GL_APIENTRY GL_TexStorageMem2DMultisampleEXT(GLenum target,
6993 GLsizei samples,
6994 GLenum internalFormat,
6995 GLsizei width,
6996 GLsizei height,
6997 GLboolean fixedSampleLocations,
6998 GLuint memory,
6999 GLuint64 offset)
7000 {
7001 Context *context = GetValidGlobalContext();
7002 EVENT(context, GLTexStorageMem2DMultisampleEXT,
7003 "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, "
7004 "fixedSampleLocations = %s, memory = %u, offset = %llu",
7005 CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples,
7006 GLenumToString(GLESEnum::SizedInternalFormat, internalFormat), width, height,
7007 GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset));
7008
7009 if (context)
7010 {
7011 TextureType targetPacked = PackParam<TextureType>(target);
7012 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
7013 SCOPED_SHARE_CONTEXT_LOCK(context);
7014 bool isCallValid =
7015 (context->skipValidation() ||
7016 (ValidatePixelLocalStorageInactive(
7017 context->getPrivateState(), context->getMutableErrorSetForValidation(),
7018 angle::EntryPoint::GLTexStorageMem2DMultisampleEXT) &&
7019 ValidateTexStorageMem2DMultisampleEXT(
7020 context, angle::EntryPoint::GLTexStorageMem2DMultisampleEXT, targetPacked,
7021 samples, internalFormat, width, height, fixedSampleLocations, memoryPacked,
7022 offset)));
7023 if (isCallValid)
7024 {
7025 context->texStorageMem2DMultisample(targetPacked, samples, internalFormat, width,
7026 height, fixedSampleLocations, memoryPacked, offset);
7027 }
7028 ANGLE_CAPTURE_GL(TexStorageMem2DMultisampleEXT, isCallValid, context, targetPacked, samples,
7029 internalFormat, width, height, fixedSampleLocations, memoryPacked, offset);
7030 }
7031 else
7032 {
7033 GenerateContextLostErrorOnCurrentGlobalContext();
7034 }
7035 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7036 }
7037
GL_TexStorageMem3DEXT(GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLuint memory,GLuint64 offset)7038 void GL_APIENTRY GL_TexStorageMem3DEXT(GLenum target,
7039 GLsizei levels,
7040 GLenum internalFormat,
7041 GLsizei width,
7042 GLsizei height,
7043 GLsizei depth,
7044 GLuint memory,
7045 GLuint64 offset)
7046 {
7047 Context *context = GetValidGlobalContext();
7048 EVENT(context, GLTexStorageMem3DEXT,
7049 "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, "
7050 "depth = %d, memory = %u, offset = %llu",
7051 CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels,
7052 GLenumToString(GLESEnum::SizedInternalFormat, internalFormat), width, height, depth,
7053 memory, static_cast<unsigned long long>(offset));
7054
7055 if (context)
7056 {
7057 TextureType targetPacked = PackParam<TextureType>(target);
7058 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
7059 SCOPED_SHARE_CONTEXT_LOCK(context);
7060 bool isCallValid =
7061 (context->skipValidation() ||
7062 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7063 context->getMutableErrorSetForValidation(),
7064 angle::EntryPoint::GLTexStorageMem3DEXT) &&
7065 ValidateTexStorageMem3DEXT(context, angle::EntryPoint::GLTexStorageMem3DEXT,
7066 targetPacked, levels, internalFormat, width, height, depth,
7067 memoryPacked, offset)));
7068 if (isCallValid)
7069 {
7070 context->texStorageMem3D(targetPacked, levels, internalFormat, width, height, depth,
7071 memoryPacked, offset);
7072 }
7073 ANGLE_CAPTURE_GL(TexStorageMem3DEXT, isCallValid, context, targetPacked, levels,
7074 internalFormat, width, height, depth, memoryPacked, offset);
7075 }
7076 else
7077 {
7078 GenerateContextLostErrorOnCurrentGlobalContext();
7079 }
7080 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7081 }
7082
GL_TexStorageMem3DMultisampleEXT(GLenum target,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset)7083 void GL_APIENTRY GL_TexStorageMem3DMultisampleEXT(GLenum target,
7084 GLsizei samples,
7085 GLenum internalFormat,
7086 GLsizei width,
7087 GLsizei height,
7088 GLsizei depth,
7089 GLboolean fixedSampleLocations,
7090 GLuint memory,
7091 GLuint64 offset)
7092 {
7093 Context *context = GetValidGlobalContext();
7094 EVENT(context, GLTexStorageMem3DMultisampleEXT,
7095 "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, "
7096 "depth = %d, fixedSampleLocations = %s, memory = %u, offset = %llu",
7097 CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples,
7098 GLenumToString(GLESEnum::SizedInternalFormat, internalFormat), width, height, depth,
7099 GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset));
7100
7101 if (context)
7102 {
7103 TextureType targetPacked = PackParam<TextureType>(target);
7104 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
7105 SCOPED_SHARE_CONTEXT_LOCK(context);
7106 bool isCallValid =
7107 (context->skipValidation() ||
7108 (ValidatePixelLocalStorageInactive(
7109 context->getPrivateState(), context->getMutableErrorSetForValidation(),
7110 angle::EntryPoint::GLTexStorageMem3DMultisampleEXT) &&
7111 ValidateTexStorageMem3DMultisampleEXT(
7112 context, angle::EntryPoint::GLTexStorageMem3DMultisampleEXT, targetPacked,
7113 samples, internalFormat, width, height, depth, fixedSampleLocations, memoryPacked,
7114 offset)));
7115 if (isCallValid)
7116 {
7117 context->texStorageMem3DMultisample(targetPacked, samples, internalFormat, width,
7118 height, depth, fixedSampleLocations, memoryPacked,
7119 offset);
7120 }
7121 ANGLE_CAPTURE_GL(TexStorageMem3DMultisampleEXT, isCallValid, context, targetPacked, samples,
7122 internalFormat, width, height, depth, fixedSampleLocations, memoryPacked,
7123 offset);
7124 }
7125 else
7126 {
7127 GenerateContextLostErrorOnCurrentGlobalContext();
7128 }
7129 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7130 }
7131
7132 // GL_EXT_memory_object_fd
GL_ImportMemoryFdEXT(GLuint memory,GLuint64 size,GLenum handleType,GLint fd)7133 void GL_APIENTRY GL_ImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleType, GLint fd)
7134 {
7135 Context *context = GetValidGlobalContext();
7136 EVENT(context, GLImportMemoryFdEXT,
7137 "context = %d, memory = %u, size = %llu, handleType = %s, fd = %d", CID(context), memory,
7138 static_cast<unsigned long long>(size),
7139 GLenumToString(GLESEnum::ExternalHandleType, handleType), fd);
7140
7141 if (context)
7142 {
7143 MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
7144 HandleType handleTypePacked = PackParam<HandleType>(handleType);
7145 SCOPED_SHARE_CONTEXT_LOCK(context);
7146 bool isCallValid =
7147 (context->skipValidation() ||
7148 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7149 context->getMutableErrorSetForValidation(),
7150 angle::EntryPoint::GLImportMemoryFdEXT) &&
7151 ValidateImportMemoryFdEXT(context, angle::EntryPoint::GLImportMemoryFdEXT,
7152 memoryPacked, size, handleTypePacked, fd)));
7153 if (isCallValid)
7154 {
7155 context->importMemoryFd(memoryPacked, size, handleTypePacked, fd);
7156 }
7157 ANGLE_CAPTURE_GL(ImportMemoryFdEXT, isCallValid, context, memoryPacked, size,
7158 handleTypePacked, fd);
7159 }
7160 else
7161 {
7162 GenerateContextLostErrorOnCurrentGlobalContext();
7163 }
7164 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7165 }
7166
7167 // GL_EXT_multi_draw_indirect
GL_MultiDrawArraysIndirectEXT(GLenum mode,const void * indirect,GLsizei drawcount,GLsizei stride)7168 void GL_APIENTRY GL_MultiDrawArraysIndirectEXT(GLenum mode,
7169 const void *indirect,
7170 GLsizei drawcount,
7171 GLsizei stride)
7172 {
7173 Context *context = GetValidGlobalContext();
7174 EVENT(context, GLMultiDrawArraysIndirectEXT,
7175 "context = %d, mode = %s, indirect = 0x%016" PRIxPTR ", drawcount = %d, stride = %d",
7176 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)indirect,
7177 drawcount, stride);
7178
7179 if (context)
7180 {
7181 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
7182 SCOPED_SHARE_CONTEXT_LOCK(context);
7183 bool isCallValid =
7184 (context->skipValidation() ||
7185 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7186 context->getMutableErrorSetForValidation(),
7187 angle::EntryPoint::GLMultiDrawArraysIndirectEXT) &&
7188 ValidateMultiDrawArraysIndirectEXT(context,
7189 angle::EntryPoint::GLMultiDrawArraysIndirectEXT,
7190 modePacked, indirect, drawcount, stride)));
7191 if (isCallValid)
7192 {
7193 context->multiDrawArraysIndirect(modePacked, indirect, drawcount, stride);
7194 }
7195 ANGLE_CAPTURE_GL(MultiDrawArraysIndirectEXT, isCallValid, context, modePacked, indirect,
7196 drawcount, stride);
7197 }
7198 else
7199 {
7200 GenerateContextLostErrorOnCurrentGlobalContext();
7201 }
7202 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7203 }
7204
GL_MultiDrawElementsIndirectEXT(GLenum mode,GLenum type,const void * indirect,GLsizei drawcount,GLsizei stride)7205 void GL_APIENTRY GL_MultiDrawElementsIndirectEXT(GLenum mode,
7206 GLenum type,
7207 const void *indirect,
7208 GLsizei drawcount,
7209 GLsizei stride)
7210 {
7211 Context *context = GetValidGlobalContext();
7212 EVENT(context, GLMultiDrawElementsIndirectEXT,
7213 "context = %d, mode = %s, type = %s, indirect = 0x%016" PRIxPTR
7214 ", drawcount = %d, stride = %d",
7215 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode),
7216 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indirect, drawcount, stride);
7217
7218 if (context)
7219 {
7220 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
7221 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
7222 SCOPED_SHARE_CONTEXT_LOCK(context);
7223 bool isCallValid =
7224 (context->skipValidation() ||
7225 (ValidatePixelLocalStorageInactive(
7226 context->getPrivateState(), context->getMutableErrorSetForValidation(),
7227 angle::EntryPoint::GLMultiDrawElementsIndirectEXT) &&
7228 ValidateMultiDrawElementsIndirectEXT(
7229 context, angle::EntryPoint::GLMultiDrawElementsIndirectEXT, modePacked,
7230 typePacked, indirect, drawcount, stride)));
7231 if (isCallValid)
7232 {
7233 context->multiDrawElementsIndirect(modePacked, typePacked, indirect, drawcount, stride);
7234 }
7235 ANGLE_CAPTURE_GL(MultiDrawElementsIndirectEXT, isCallValid, context, modePacked, typePacked,
7236 indirect, drawcount, stride);
7237 }
7238 else
7239 {
7240 GenerateContextLostErrorOnCurrentGlobalContext();
7241 }
7242 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7243 }
7244
7245 // GL_EXT_multisampled_render_to_texture
GL_FramebufferTexture2DMultisampleEXT(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLsizei samples)7246 void GL_APIENTRY GL_FramebufferTexture2DMultisampleEXT(GLenum target,
7247 GLenum attachment,
7248 GLenum textarget,
7249 GLuint texture,
7250 GLint level,
7251 GLsizei samples)
7252 {
7253 Context *context = GetValidGlobalContext();
7254 EVENT(context, GLFramebufferTexture2DMultisampleEXT,
7255 "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, "
7256 "samples = %d",
7257 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
7258 GLenumToString(GLESEnum::FramebufferAttachment, attachment),
7259 GLenumToString(GLESEnum::TextureTarget, textarget), texture, level, samples);
7260
7261 if (context)
7262 {
7263 TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
7264 TextureID texturePacked = PackParam<TextureID>(texture);
7265 SCOPED_SHARE_CONTEXT_LOCK(context);
7266 bool isCallValid =
7267 (context->skipValidation() ||
7268 (ValidatePixelLocalStorageInactive(
7269 context->getPrivateState(), context->getMutableErrorSetForValidation(),
7270 angle::EntryPoint::GLFramebufferTexture2DMultisampleEXT) &&
7271 ValidateFramebufferTexture2DMultisampleEXT(
7272 context, angle::EntryPoint::GLFramebufferTexture2DMultisampleEXT, target,
7273 attachment, textargetPacked, texturePacked, level, samples)));
7274 if (isCallValid)
7275 {
7276 context->framebufferTexture2DMultisample(target, attachment, textargetPacked,
7277 texturePacked, level, samples);
7278 }
7279 ANGLE_CAPTURE_GL(FramebufferTexture2DMultisampleEXT, isCallValid, context, target,
7280 attachment, textargetPacked, texturePacked, level, samples);
7281 }
7282 else
7283 {
7284 GenerateContextLostErrorOnCurrentGlobalContext();
7285 }
7286 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7287 }
7288
GL_RenderbufferStorageMultisampleEXT(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)7289 void GL_APIENTRY GL_RenderbufferStorageMultisampleEXT(GLenum target,
7290 GLsizei samples,
7291 GLenum internalformat,
7292 GLsizei width,
7293 GLsizei height)
7294 {
7295 Context *context = GetValidGlobalContext();
7296 EVENT(context, GLRenderbufferStorageMultisampleEXT,
7297 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d",
7298 CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target), samples,
7299 GLenumToString(GLESEnum::InternalFormat, internalformat), width, height);
7300
7301 if (context)
7302 {
7303 SCOPED_SHARE_CONTEXT_LOCK(context);
7304 bool isCallValid =
7305 (context->skipValidation() ||
7306 (ValidatePixelLocalStorageInactive(
7307 context->getPrivateState(), context->getMutableErrorSetForValidation(),
7308 angle::EntryPoint::GLRenderbufferStorageMultisampleEXT) &&
7309 ValidateRenderbufferStorageMultisampleEXT(
7310 context, angle::EntryPoint::GLRenderbufferStorageMultisampleEXT, target, samples,
7311 internalformat, width, height)));
7312 if (isCallValid)
7313 {
7314 context->renderbufferStorageMultisampleEXT(target, samples, internalformat, width,
7315 height);
7316 }
7317 ANGLE_CAPTURE_GL(RenderbufferStorageMultisampleEXT, isCallValid, context, target, samples,
7318 internalformat, width, height);
7319 }
7320 else
7321 {
7322 GenerateContextLostErrorOnCurrentGlobalContext();
7323 }
7324 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7325 }
7326
7327 // GL_EXT_multisampled_render_to_texture2
7328
7329 // GL_EXT_occlusion_query_boolean
7330 // BeginQueryEXT is already defined.
7331
7332 // DeleteQueriesEXT is already defined.
7333
7334 // EndQueryEXT is already defined.
7335
7336 // GenQueriesEXT is already defined.
7337
7338 // GetQueryObjectuivEXT is already defined.
7339
7340 // GetQueryivEXT is already defined.
7341
7342 // IsQueryEXT is already defined.
7343
7344 // GL_EXT_polygon_offset_clamp
GL_PolygonOffsetClampEXT(GLfloat factor,GLfloat units,GLfloat clamp)7345 void GL_APIENTRY GL_PolygonOffsetClampEXT(GLfloat factor, GLfloat units, GLfloat clamp)
7346 {
7347 Context *context = GetValidGlobalContext();
7348 EVENT(context, GLPolygonOffsetClampEXT, "context = %d, factor = %f, units = %f, clamp = %f",
7349 CID(context), factor, units, clamp);
7350
7351 if (context)
7352 {
7353 bool isCallValid =
7354 (context->skipValidation() ||
7355 ValidatePolygonOffsetClampEXT(
7356 context->getPrivateState(), context->getMutableErrorSetForValidation(),
7357 angle::EntryPoint::GLPolygonOffsetClampEXT, factor, units, clamp));
7358 if (isCallValid)
7359 {
7360 ContextPrivatePolygonOffsetClamp(context->getMutablePrivateState(),
7361 context->getMutablePrivateStateCache(), factor, units,
7362 clamp);
7363 }
7364 ANGLE_CAPTURE_GL(PolygonOffsetClampEXT, isCallValid, context, factor, units, clamp);
7365 }
7366 else
7367 {
7368 GenerateContextLostErrorOnCurrentGlobalContext();
7369 }
7370 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7371 }
7372
7373 // GL_EXT_primitive_bounding_box
GL_PrimitiveBoundingBoxEXT(GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW)7374 void GL_APIENTRY GL_PrimitiveBoundingBoxEXT(GLfloat minX,
7375 GLfloat minY,
7376 GLfloat minZ,
7377 GLfloat minW,
7378 GLfloat maxX,
7379 GLfloat maxY,
7380 GLfloat maxZ,
7381 GLfloat maxW)
7382 {
7383 Context *context = GetValidGlobalContext();
7384 EVENT(context, GLPrimitiveBoundingBoxEXT,
7385 "context = %d, minX = %f, minY = %f, minZ = %f, minW = %f, maxX = %f, maxY = %f, maxZ = "
7386 "%f, maxW = %f",
7387 CID(context), minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
7388
7389 if (context)
7390 {
7391 bool isCallValid =
7392 (context->skipValidation() ||
7393 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7394 context->getMutableErrorSetForValidation(),
7395 angle::EntryPoint::GLPrimitiveBoundingBoxEXT) &&
7396 ValidatePrimitiveBoundingBoxEXT(context->getPrivateState(),
7397 context->getMutableErrorSetForValidation(),
7398 angle::EntryPoint::GLPrimitiveBoundingBoxEXT, minX,
7399 minY, minZ, minW, maxX, maxY, maxZ, maxW)));
7400 if (isCallValid)
7401 {
7402 ContextPrivatePrimitiveBoundingBox(context->getMutablePrivateState(),
7403 context->getMutablePrivateStateCache(), minX, minY,
7404 minZ, minW, maxX, maxY, maxZ, maxW);
7405 }
7406 ANGLE_CAPTURE_GL(PrimitiveBoundingBoxEXT, isCallValid, context, minX, minY, minZ, minW,
7407 maxX, maxY, maxZ, maxW);
7408 }
7409 else
7410 {
7411 GenerateContextLostErrorOnCurrentGlobalContext();
7412 }
7413 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7414 }
7415
7416 // GL_EXT_protected_textures
7417
7418 // GL_EXT_pvrtc_sRGB
7419
7420 // GL_EXT_read_format_bgra
7421
7422 // GL_EXT_render_snorm
7423
7424 // GL_EXT_robustness
GL_GetGraphicsResetStatusEXT()7425 GLenum GL_APIENTRY GL_GetGraphicsResetStatusEXT()
7426 {
7427 Context *context = GetGlobalContext();
7428 EVENT(context, GLGetGraphicsResetStatusEXT, "context = %d", CID(context));
7429
7430 GLenum returnValue;
7431 if (context)
7432 {
7433 SCOPED_SHARE_CONTEXT_LOCK(context);
7434 bool isCallValid = (context->skipValidation() ||
7435 ValidateGetGraphicsResetStatusEXT(
7436 context, angle::EntryPoint::GLGetGraphicsResetStatusEXT));
7437 if (isCallValid)
7438 {
7439 returnValue = context->getGraphicsResetStatus();
7440 }
7441 else
7442 {
7443 returnValue =
7444 GetDefaultReturnValue<angle::EntryPoint::GLGetGraphicsResetStatusEXT, GLenum>();
7445 }
7446 ANGLE_CAPTURE_GL(GetGraphicsResetStatusEXT, isCallValid, context, returnValue);
7447 }
7448 else
7449 {
7450
7451 returnValue =
7452 GetDefaultReturnValue<angle::EntryPoint::GLGetGraphicsResetStatusEXT, GLenum>();
7453 }
7454 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7455 return returnValue;
7456 }
7457
GL_GetnUniformfvEXT(GLuint program,GLint location,GLsizei bufSize,GLfloat * params)7458 void GL_APIENTRY GL_GetnUniformfvEXT(GLuint program,
7459 GLint location,
7460 GLsizei bufSize,
7461 GLfloat *params)
7462 {
7463 Context *context = GetValidGlobalContext();
7464 EVENT(context, GLGetnUniformfvEXT,
7465 "context = %d, program = %u, location = %d, bufSize = %d, params = 0x%016" PRIxPTR "",
7466 CID(context), program, location, bufSize, (uintptr_t)params);
7467
7468 if (context)
7469 {
7470 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7471 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7472 SCOPED_SHARE_CONTEXT_LOCK(context);
7473 bool isCallValid =
7474 (context->skipValidation() ||
7475 ValidateGetnUniformfvEXT(context, angle::EntryPoint::GLGetnUniformfvEXT, programPacked,
7476 locationPacked, bufSize, params));
7477 if (isCallValid)
7478 {
7479 context->getnUniformfv(programPacked, locationPacked, bufSize, params);
7480 }
7481 ANGLE_CAPTURE_GL(GetnUniformfvEXT, isCallValid, context, programPacked, locationPacked,
7482 bufSize, params);
7483 }
7484 else
7485 {
7486 GenerateContextLostErrorOnCurrentGlobalContext();
7487 }
7488 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7489 }
7490
GL_GetnUniformivEXT(GLuint program,GLint location,GLsizei bufSize,GLint * params)7491 void GL_APIENTRY GL_GetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params)
7492 {
7493 Context *context = GetValidGlobalContext();
7494 EVENT(context, GLGetnUniformivEXT,
7495 "context = %d, program = %u, location = %d, bufSize = %d, params = 0x%016" PRIxPTR "",
7496 CID(context), program, location, bufSize, (uintptr_t)params);
7497
7498 if (context)
7499 {
7500 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7501 UniformLocation locationPacked = PackParam<UniformLocation>(location);
7502 SCOPED_SHARE_CONTEXT_LOCK(context);
7503 bool isCallValid =
7504 (context->skipValidation() ||
7505 ValidateGetnUniformivEXT(context, angle::EntryPoint::GLGetnUniformivEXT, programPacked,
7506 locationPacked, bufSize, params));
7507 if (isCallValid)
7508 {
7509 context->getnUniformiv(programPacked, locationPacked, bufSize, params);
7510 }
7511 ANGLE_CAPTURE_GL(GetnUniformivEXT, isCallValid, context, programPacked, locationPacked,
7512 bufSize, params);
7513 }
7514 else
7515 {
7516 GenerateContextLostErrorOnCurrentGlobalContext();
7517 }
7518 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7519 }
7520
GL_ReadnPixelsEXT(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)7521 void GL_APIENTRY GL_ReadnPixelsEXT(GLint x,
7522 GLint y,
7523 GLsizei width,
7524 GLsizei height,
7525 GLenum format,
7526 GLenum type,
7527 GLsizei bufSize,
7528 void *data)
7529 {
7530 Context *context = GetValidGlobalContext();
7531 EVENT(context, GLReadnPixelsEXT,
7532 "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize "
7533 "= %d, data = 0x%016" PRIxPTR "",
7534 CID(context), x, y, width, height, GLenumToString(GLESEnum::PixelFormat, format),
7535 GLenumToString(GLESEnum::PixelType, type), bufSize, (uintptr_t)data);
7536
7537 if (context)
7538 {
7539 SCOPED_SHARE_CONTEXT_LOCK(context);
7540 bool isCallValid =
7541 (context->skipValidation() ||
7542 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7543 context->getMutableErrorSetForValidation(),
7544 angle::EntryPoint::GLReadnPixelsEXT) &&
7545 ValidateReadnPixelsEXT(context, angle::EntryPoint::GLReadnPixelsEXT, x, y, width,
7546 height, format, type, bufSize, data)));
7547 if (isCallValid)
7548 {
7549 context->readnPixels(x, y, width, height, format, type, bufSize, data);
7550 }
7551 ANGLE_CAPTURE_GL(ReadnPixelsEXT, isCallValid, context, x, y, width, height, format, type,
7552 bufSize, data);
7553 }
7554 else
7555 {
7556 GenerateContextLostErrorOnCurrentGlobalContext();
7557 }
7558 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7559 }
7560
7561 // GL_EXT_sRGB
7562
7563 // GL_EXT_sRGB_write_control
7564
7565 // GL_EXT_semaphore
GL_DeleteSemaphoresEXT(GLsizei n,const GLuint * semaphores)7566 void GL_APIENTRY GL_DeleteSemaphoresEXT(GLsizei n, const GLuint *semaphores)
7567 {
7568 Context *context = GetValidGlobalContext();
7569 EVENT(context, GLDeleteSemaphoresEXT, "context = %d, n = %d, semaphores = 0x%016" PRIxPTR "",
7570 CID(context), n, (uintptr_t)semaphores);
7571
7572 if (context)
7573 {
7574 const SemaphoreID *semaphoresPacked = PackParam<const SemaphoreID *>(semaphores);
7575 SCOPED_SHARE_CONTEXT_LOCK(context);
7576 bool isCallValid =
7577 (context->skipValidation() ||
7578 ValidateDeleteSemaphoresEXT(context, angle::EntryPoint::GLDeleteSemaphoresEXT, n,
7579 semaphoresPacked));
7580 if (isCallValid)
7581 {
7582 context->deleteSemaphores(n, semaphoresPacked);
7583 }
7584 ANGLE_CAPTURE_GL(DeleteSemaphoresEXT, isCallValid, context, n, semaphoresPacked);
7585 }
7586 else
7587 {
7588 GenerateContextLostErrorOnCurrentGlobalContext();
7589 }
7590 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7591 }
7592
GL_GenSemaphoresEXT(GLsizei n,GLuint * semaphores)7593 void GL_APIENTRY GL_GenSemaphoresEXT(GLsizei n, GLuint *semaphores)
7594 {
7595 Context *context = GetValidGlobalContext();
7596 EVENT(context, GLGenSemaphoresEXT, "context = %d, n = %d, semaphores = 0x%016" PRIxPTR "",
7597 CID(context), n, (uintptr_t)semaphores);
7598
7599 if (context)
7600 {
7601 SemaphoreID *semaphoresPacked = PackParam<SemaphoreID *>(semaphores);
7602 SCOPED_SHARE_CONTEXT_LOCK(context);
7603 bool isCallValid = (context->skipValidation() ||
7604 ValidateGenSemaphoresEXT(context, angle::EntryPoint::GLGenSemaphoresEXT,
7605 n, semaphoresPacked));
7606 if (isCallValid)
7607 {
7608 context->genSemaphores(n, semaphoresPacked);
7609 }
7610 ANGLE_CAPTURE_GL(GenSemaphoresEXT, isCallValid, context, n, semaphoresPacked);
7611 }
7612 else
7613 {
7614 GenerateContextLostErrorOnCurrentGlobalContext();
7615 }
7616 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7617 }
7618
GL_GetSemaphoreParameterui64vEXT(GLuint semaphore,GLenum pname,GLuint64 * params)7619 void GL_APIENTRY GL_GetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, GLuint64 *params)
7620 {
7621 Context *context = GetValidGlobalContext();
7622 EVENT(context, GLGetSemaphoreParameterui64vEXT,
7623 "context = %d, semaphore = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
7624 semaphore, GLenumToString(GLESEnum::SemaphoreParameterName, pname), (uintptr_t)params);
7625
7626 if (context)
7627 {
7628 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
7629 SCOPED_SHARE_CONTEXT_LOCK(context);
7630 bool isCallValid = (context->skipValidation() ||
7631 ValidateGetSemaphoreParameterui64vEXT(
7632 context, angle::EntryPoint::GLGetSemaphoreParameterui64vEXT,
7633 semaphorePacked, pname, params));
7634 if (isCallValid)
7635 {
7636 context->getSemaphoreParameterui64v(semaphorePacked, pname, params);
7637 }
7638 ANGLE_CAPTURE_GL(GetSemaphoreParameterui64vEXT, isCallValid, context, semaphorePacked,
7639 pname, params);
7640 }
7641 else
7642 {
7643 GenerateContextLostErrorOnCurrentGlobalContext();
7644 }
7645 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7646 }
7647
GL_IsSemaphoreEXT(GLuint semaphore)7648 GLboolean GL_APIENTRY GL_IsSemaphoreEXT(GLuint semaphore)
7649 {
7650 Context *context = GetValidGlobalContext();
7651 EVENT(context, GLIsSemaphoreEXT, "context = %d, semaphore = %u", CID(context), semaphore);
7652
7653 GLboolean returnValue;
7654 if (context)
7655 {
7656 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
7657 SCOPED_SHARE_CONTEXT_LOCK(context);
7658 bool isCallValid =
7659 (context->skipValidation() ||
7660 ValidateIsSemaphoreEXT(context, angle::EntryPoint::GLIsSemaphoreEXT, semaphorePacked));
7661 if (isCallValid)
7662 {
7663 returnValue = context->isSemaphore(semaphorePacked);
7664 }
7665 else
7666 {
7667 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSemaphoreEXT, GLboolean>();
7668 }
7669 ANGLE_CAPTURE_GL(IsSemaphoreEXT, isCallValid, context, semaphorePacked, returnValue);
7670 }
7671 else
7672 {
7673 GenerateContextLostErrorOnCurrentGlobalContext();
7674 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSemaphoreEXT, GLboolean>();
7675 }
7676 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7677 return returnValue;
7678 }
7679
GL_SemaphoreParameterui64vEXT(GLuint semaphore,GLenum pname,const GLuint64 * params)7680 void GL_APIENTRY GL_SemaphoreParameterui64vEXT(GLuint semaphore,
7681 GLenum pname,
7682 const GLuint64 *params)
7683 {
7684 Context *context = GetValidGlobalContext();
7685 EVENT(context, GLSemaphoreParameterui64vEXT,
7686 "context = %d, semaphore = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
7687 semaphore, GLenumToString(GLESEnum::SemaphoreParameterName, pname), (uintptr_t)params);
7688
7689 if (context)
7690 {
7691 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
7692 SCOPED_SHARE_CONTEXT_LOCK(context);
7693 bool isCallValid =
7694 (context->skipValidation() ||
7695 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7696 context->getMutableErrorSetForValidation(),
7697 angle::EntryPoint::GLSemaphoreParameterui64vEXT) &&
7698 ValidateSemaphoreParameterui64vEXT(context,
7699 angle::EntryPoint::GLSemaphoreParameterui64vEXT,
7700 semaphorePacked, pname, params)));
7701 if (isCallValid)
7702 {
7703 context->semaphoreParameterui64v(semaphorePacked, pname, params);
7704 }
7705 ANGLE_CAPTURE_GL(SemaphoreParameterui64vEXT, isCallValid, context, semaphorePacked, pname,
7706 params);
7707 }
7708 else
7709 {
7710 GenerateContextLostErrorOnCurrentGlobalContext();
7711 }
7712 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7713 }
7714
GL_SignalSemaphoreEXT(GLuint semaphore,GLuint numBufferBarriers,const GLuint * buffers,GLuint numTextureBarriers,const GLuint * textures,const GLenum * dstLayouts)7715 void GL_APIENTRY GL_SignalSemaphoreEXT(GLuint semaphore,
7716 GLuint numBufferBarriers,
7717 const GLuint *buffers,
7718 GLuint numTextureBarriers,
7719 const GLuint *textures,
7720 const GLenum *dstLayouts)
7721 {
7722 Context *context = GetValidGlobalContext();
7723 EVENT(context, GLSignalSemaphoreEXT,
7724 "context = %d, semaphore = %u, numBufferBarriers = %u, buffers = 0x%016" PRIxPTR
7725 ", numTextureBarriers = %u, textures = 0x%016" PRIxPTR ", dstLayouts = 0x%016" PRIxPTR "",
7726 CID(context), semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers,
7727 (uintptr_t)textures, (uintptr_t)dstLayouts);
7728
7729 if (context)
7730 {
7731 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
7732 const BufferID *buffersPacked = PackParam<const BufferID *>(buffers);
7733 const TextureID *texturesPacked = PackParam<const TextureID *>(textures);
7734 SCOPED_SHARE_CONTEXT_LOCK(context);
7735 bool isCallValid =
7736 (context->skipValidation() ||
7737 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7738 context->getMutableErrorSetForValidation(),
7739 angle::EntryPoint::GLSignalSemaphoreEXT) &&
7740 ValidateSignalSemaphoreEXT(context, angle::EntryPoint::GLSignalSemaphoreEXT,
7741 semaphorePacked, numBufferBarriers, buffersPacked,
7742 numTextureBarriers, texturesPacked, dstLayouts)));
7743 if (isCallValid)
7744 {
7745 context->signalSemaphore(semaphorePacked, numBufferBarriers, buffersPacked,
7746 numTextureBarriers, texturesPacked, dstLayouts);
7747 }
7748 ANGLE_CAPTURE_GL(SignalSemaphoreEXT, isCallValid, context, semaphorePacked,
7749 numBufferBarriers, buffersPacked, numTextureBarriers, texturesPacked,
7750 dstLayouts);
7751 }
7752 else
7753 {
7754 GenerateContextLostErrorOnCurrentGlobalContext();
7755 }
7756 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7757 }
7758
GL_WaitSemaphoreEXT(GLuint semaphore,GLuint numBufferBarriers,const GLuint * buffers,GLuint numTextureBarriers,const GLuint * textures,const GLenum * srcLayouts)7759 void GL_APIENTRY GL_WaitSemaphoreEXT(GLuint semaphore,
7760 GLuint numBufferBarriers,
7761 const GLuint *buffers,
7762 GLuint numTextureBarriers,
7763 const GLuint *textures,
7764 const GLenum *srcLayouts)
7765 {
7766 Context *context = GetValidGlobalContext();
7767 EVENT(context, GLWaitSemaphoreEXT,
7768 "context = %d, semaphore = %u, numBufferBarriers = %u, buffers = 0x%016" PRIxPTR
7769 ", numTextureBarriers = %u, textures = 0x%016" PRIxPTR ", srcLayouts = 0x%016" PRIxPTR "",
7770 CID(context), semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers,
7771 (uintptr_t)textures, (uintptr_t)srcLayouts);
7772
7773 if (context)
7774 {
7775 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
7776 const BufferID *buffersPacked = PackParam<const BufferID *>(buffers);
7777 const TextureID *texturesPacked = PackParam<const TextureID *>(textures);
7778 SCOPED_SHARE_CONTEXT_LOCK(context);
7779 bool isCallValid =
7780 (context->skipValidation() ||
7781 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7782 context->getMutableErrorSetForValidation(),
7783 angle::EntryPoint::GLWaitSemaphoreEXT) &&
7784 ValidateWaitSemaphoreEXT(context, angle::EntryPoint::GLWaitSemaphoreEXT,
7785 semaphorePacked, numBufferBarriers, buffersPacked,
7786 numTextureBarriers, texturesPacked, srcLayouts)));
7787 if (isCallValid)
7788 {
7789 context->waitSemaphore(semaphorePacked, numBufferBarriers, buffersPacked,
7790 numTextureBarriers, texturesPacked, srcLayouts);
7791 }
7792 ANGLE_CAPTURE_GL(WaitSemaphoreEXT, isCallValid, context, semaphorePacked, numBufferBarriers,
7793 buffersPacked, numTextureBarriers, texturesPacked, srcLayouts);
7794 }
7795 else
7796 {
7797 GenerateContextLostErrorOnCurrentGlobalContext();
7798 }
7799 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7800 }
7801
7802 // GetUnsignedBytei_vEXT is already defined.
7803
7804 // GetUnsignedBytevEXT is already defined.
7805
7806 // GL_EXT_semaphore_fd
GL_ImportSemaphoreFdEXT(GLuint semaphore,GLenum handleType,GLint fd)7807 void GL_APIENTRY GL_ImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd)
7808 {
7809 Context *context = GetValidGlobalContext();
7810 EVENT(context, GLImportSemaphoreFdEXT, "context = %d, semaphore = %u, handleType = %s, fd = %d",
7811 CID(context), semaphore, GLenumToString(GLESEnum::ExternalHandleType, handleType), fd);
7812
7813 if (context)
7814 {
7815 SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
7816 HandleType handleTypePacked = PackParam<HandleType>(handleType);
7817 SCOPED_SHARE_CONTEXT_LOCK(context);
7818 bool isCallValid =
7819 (context->skipValidation() ||
7820 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7821 context->getMutableErrorSetForValidation(),
7822 angle::EntryPoint::GLImportSemaphoreFdEXT) &&
7823 ValidateImportSemaphoreFdEXT(context, angle::EntryPoint::GLImportSemaphoreFdEXT,
7824 semaphorePacked, handleTypePacked, fd)));
7825 if (isCallValid)
7826 {
7827 context->importSemaphoreFd(semaphorePacked, handleTypePacked, fd);
7828 }
7829 ANGLE_CAPTURE_GL(ImportSemaphoreFdEXT, isCallValid, context, semaphorePacked,
7830 handleTypePacked, fd);
7831 }
7832 else
7833 {
7834 GenerateContextLostErrorOnCurrentGlobalContext();
7835 }
7836 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7837 }
7838
7839 // GL_EXT_separate_shader_objects
GL_ActiveShaderProgramEXT(GLuint pipeline,GLuint program)7840 void GL_APIENTRY GL_ActiveShaderProgramEXT(GLuint pipeline, GLuint program)
7841 {
7842 Context *context = GetValidGlobalContext();
7843 EVENT(context, GLActiveShaderProgramEXT, "context = %d, pipeline = %u, program = %u",
7844 CID(context), pipeline, program);
7845
7846 if (context)
7847 {
7848 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
7849 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
7850 SCOPED_SHARE_CONTEXT_LOCK(context);
7851 bool isCallValid =
7852 (context->skipValidation() ||
7853 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7854 context->getMutableErrorSetForValidation(),
7855 angle::EntryPoint::GLActiveShaderProgramEXT) &&
7856 ValidateActiveShaderProgramEXT(context, angle::EntryPoint::GLActiveShaderProgramEXT,
7857 pipelinePacked, programPacked)));
7858 if (isCallValid)
7859 {
7860 context->activeShaderProgram(pipelinePacked, programPacked);
7861 }
7862 ANGLE_CAPTURE_GL(ActiveShaderProgramEXT, isCallValid, context, pipelinePacked,
7863 programPacked);
7864 }
7865 else
7866 {
7867 GenerateContextLostErrorOnCurrentGlobalContext();
7868 }
7869 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7870 }
7871
GL_BindProgramPipelineEXT(GLuint pipeline)7872 void GL_APIENTRY GL_BindProgramPipelineEXT(GLuint pipeline)
7873 {
7874 Context *context = GetValidGlobalContext();
7875 EVENT(context, GLBindProgramPipelineEXT, "context = %d, pipeline = %u", CID(context), pipeline);
7876
7877 if (context)
7878 {
7879 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
7880 SCOPED_SHARE_CONTEXT_LOCK(context);
7881 bool isCallValid =
7882 (context->skipValidation() ||
7883 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7884 context->getMutableErrorSetForValidation(),
7885 angle::EntryPoint::GLBindProgramPipelineEXT) &&
7886 ValidateBindProgramPipelineEXT(context, angle::EntryPoint::GLBindProgramPipelineEXT,
7887 pipelinePacked)));
7888 if (isCallValid)
7889 {
7890 context->bindProgramPipeline(pipelinePacked);
7891 }
7892 ANGLE_CAPTURE_GL(BindProgramPipelineEXT, isCallValid, context, pipelinePacked);
7893 }
7894 else
7895 {
7896 GenerateContextLostErrorOnCurrentGlobalContext();
7897 }
7898 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7899 }
7900
GL_CreateShaderProgramvEXT(GLenum type,GLsizei count,const GLchar ** strings)7901 GLuint GL_APIENTRY GL_CreateShaderProgramvEXT(GLenum type, GLsizei count, const GLchar **strings)
7902 {
7903 Context *context = GetValidGlobalContext();
7904 EVENT(context, GLCreateShaderProgramvEXT,
7905 "context = %d, type = %s, count = %d, strings = 0x%016" PRIxPTR "", CID(context),
7906 GLenumToString(GLESEnum::ShaderType, type), count, (uintptr_t)strings);
7907
7908 GLuint returnValue;
7909 if (context)
7910 {
7911 ShaderType typePacked = PackParam<ShaderType>(type);
7912 SCOPED_SHARE_CONTEXT_LOCK(context);
7913 bool isCallValid =
7914 (context->skipValidation() ||
7915 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
7916 context->getMutableErrorSetForValidation(),
7917 angle::EntryPoint::GLCreateShaderProgramvEXT) &&
7918 ValidateCreateShaderProgramvEXT(context, angle::EntryPoint::GLCreateShaderProgramvEXT,
7919 typePacked, count, strings)));
7920 if (isCallValid)
7921 {
7922 returnValue = context->createShaderProgramv(typePacked, count, strings);
7923 }
7924 else
7925 {
7926 returnValue =
7927 GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramvEXT, GLuint>();
7928 }
7929 ANGLE_CAPTURE_GL(CreateShaderProgramvEXT, isCallValid, context, typePacked, count, strings,
7930 returnValue);
7931 }
7932 else
7933 {
7934 GenerateContextLostErrorOnCurrentGlobalContext();
7935 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramvEXT, GLuint>();
7936 }
7937 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7938 return returnValue;
7939 }
7940
GL_DeleteProgramPipelinesEXT(GLsizei n,const GLuint * pipelines)7941 void GL_APIENTRY GL_DeleteProgramPipelinesEXT(GLsizei n, const GLuint *pipelines)
7942 {
7943 Context *context = GetValidGlobalContext();
7944 EVENT(context, GLDeleteProgramPipelinesEXT,
7945 "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "", CID(context), n,
7946 (uintptr_t)pipelines);
7947
7948 if (context)
7949 {
7950 const ProgramPipelineID *pipelinesPacked = PackParam<const ProgramPipelineID *>(pipelines);
7951 SCOPED_SHARE_CONTEXT_LOCK(context);
7952 bool isCallValid =
7953 (context->skipValidation() ||
7954 ValidateDeleteProgramPipelinesEXT(
7955 context, angle::EntryPoint::GLDeleteProgramPipelinesEXT, n, pipelinesPacked));
7956 if (isCallValid)
7957 {
7958 context->deleteProgramPipelines(n, pipelinesPacked);
7959 }
7960 ANGLE_CAPTURE_GL(DeleteProgramPipelinesEXT, isCallValid, context, n, pipelinesPacked);
7961 }
7962 else
7963 {
7964 GenerateContextLostErrorOnCurrentGlobalContext();
7965 }
7966 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7967 }
7968
GL_GenProgramPipelinesEXT(GLsizei n,GLuint * pipelines)7969 void GL_APIENTRY GL_GenProgramPipelinesEXT(GLsizei n, GLuint *pipelines)
7970 {
7971 Context *context = GetValidGlobalContext();
7972 EVENT(context, GLGenProgramPipelinesEXT, "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "",
7973 CID(context), n, (uintptr_t)pipelines);
7974
7975 if (context)
7976 {
7977 ProgramPipelineID *pipelinesPacked = PackParam<ProgramPipelineID *>(pipelines);
7978 SCOPED_SHARE_CONTEXT_LOCK(context);
7979 bool isCallValid =
7980 (context->skipValidation() ||
7981 ValidateGenProgramPipelinesEXT(context, angle::EntryPoint::GLGenProgramPipelinesEXT, n,
7982 pipelinesPacked));
7983 if (isCallValid)
7984 {
7985 context->genProgramPipelines(n, pipelinesPacked);
7986 }
7987 ANGLE_CAPTURE_GL(GenProgramPipelinesEXT, isCallValid, context, n, pipelinesPacked);
7988 }
7989 else
7990 {
7991 GenerateContextLostErrorOnCurrentGlobalContext();
7992 }
7993 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
7994 }
7995
GL_GetProgramPipelineInfoLogEXT(GLuint pipeline,GLsizei bufSize,GLsizei * length,GLchar * infoLog)7996 void GL_APIENTRY GL_GetProgramPipelineInfoLogEXT(GLuint pipeline,
7997 GLsizei bufSize,
7998 GLsizei *length,
7999 GLchar *infoLog)
8000 {
8001 Context *context = GetValidGlobalContext();
8002 EVENT(context, GLGetProgramPipelineInfoLogEXT,
8003 "context = %d, pipeline = %u, bufSize = %d, length = 0x%016" PRIxPTR
8004 ", infoLog = 0x%016" PRIxPTR "",
8005 CID(context), pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
8006
8007 if (context)
8008 {
8009 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
8010 SCOPED_SHARE_CONTEXT_LOCK(context);
8011 bool isCallValid = (context->skipValidation() ||
8012 ValidateGetProgramPipelineInfoLogEXT(
8013 context, angle::EntryPoint::GLGetProgramPipelineInfoLogEXT,
8014 pipelinePacked, bufSize, length, infoLog));
8015 if (isCallValid)
8016 {
8017 context->getProgramPipelineInfoLog(pipelinePacked, bufSize, length, infoLog);
8018 }
8019 ANGLE_CAPTURE_GL(GetProgramPipelineInfoLogEXT, isCallValid, context, pipelinePacked,
8020 bufSize, length, infoLog);
8021 }
8022 else
8023 {
8024 GenerateContextLostErrorOnCurrentGlobalContext();
8025 }
8026 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8027 }
8028
GL_GetProgramPipelineivEXT(GLuint pipeline,GLenum pname,GLint * params)8029 void GL_APIENTRY GL_GetProgramPipelineivEXT(GLuint pipeline, GLenum pname, GLint *params)
8030 {
8031 Context *context = GetValidGlobalContext();
8032 EVENT(context, GLGetProgramPipelineivEXT,
8033 "context = %d, pipeline = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
8034 pipeline, GLenumToString(GLESEnum::PipelineParameterName, pname), (uintptr_t)params);
8035
8036 if (context)
8037 {
8038 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
8039 SCOPED_SHARE_CONTEXT_LOCK(context);
8040 bool isCallValid =
8041 (context->skipValidation() ||
8042 ValidateGetProgramPipelineivEXT(context, angle::EntryPoint::GLGetProgramPipelineivEXT,
8043 pipelinePacked, pname, params));
8044 if (isCallValid)
8045 {
8046 context->getProgramPipelineiv(pipelinePacked, pname, params);
8047 }
8048 ANGLE_CAPTURE_GL(GetProgramPipelineivEXT, isCallValid, context, pipelinePacked, pname,
8049 params);
8050 }
8051 else
8052 {
8053 GenerateContextLostErrorOnCurrentGlobalContext();
8054 }
8055 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8056 }
8057
GL_IsProgramPipelineEXT(GLuint pipeline)8058 GLboolean GL_APIENTRY GL_IsProgramPipelineEXT(GLuint pipeline)
8059 {
8060 Context *context = GetValidGlobalContext();
8061 EVENT(context, GLIsProgramPipelineEXT, "context = %d, pipeline = %u", CID(context), pipeline);
8062
8063 GLboolean returnValue;
8064 if (context)
8065 {
8066 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
8067 SCOPED_SHARE_CONTEXT_LOCK(context);
8068 bool isCallValid =
8069 (context->skipValidation() ||
8070 ValidateIsProgramPipelineEXT(context, angle::EntryPoint::GLIsProgramPipelineEXT,
8071 pipelinePacked));
8072 if (isCallValid)
8073 {
8074 returnValue = context->isProgramPipeline(pipelinePacked);
8075 }
8076 else
8077 {
8078 returnValue =
8079 GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipelineEXT, GLboolean>();
8080 }
8081 ANGLE_CAPTURE_GL(IsProgramPipelineEXT, isCallValid, context, pipelinePacked, returnValue);
8082 }
8083 else
8084 {
8085 GenerateContextLostErrorOnCurrentGlobalContext();
8086 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipelineEXT, GLboolean>();
8087 }
8088 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8089 return returnValue;
8090 }
8091
GL_ProgramParameteriEXT(GLuint program,GLenum pname,GLint value)8092 void GL_APIENTRY GL_ProgramParameteriEXT(GLuint program, GLenum pname, GLint value)
8093 {
8094 Context *context = GetValidGlobalContext();
8095 EVENT(context, GLProgramParameteriEXT, "context = %d, program = %u, pname = %s, value = %d",
8096 CID(context), program, GLenumToString(GLESEnum::ProgramParameterPName, pname), value);
8097
8098 if (context)
8099 {
8100 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8101 SCOPED_SHARE_CONTEXT_LOCK(context);
8102 bool isCallValid =
8103 (context->skipValidation() ||
8104 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8105 context->getMutableErrorSetForValidation(),
8106 angle::EntryPoint::GLProgramParameteriEXT) &&
8107 ValidateProgramParameteriEXT(context, angle::EntryPoint::GLProgramParameteriEXT,
8108 programPacked, pname, value)));
8109 if (isCallValid)
8110 {
8111 context->programParameteri(programPacked, pname, value);
8112 }
8113 ANGLE_CAPTURE_GL(ProgramParameteriEXT, isCallValid, context, programPacked, pname, value);
8114 }
8115 else
8116 {
8117 GenerateContextLostErrorOnCurrentGlobalContext();
8118 }
8119 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8120 }
8121
GL_ProgramUniform1fEXT(GLuint program,GLint location,GLfloat v0)8122 void GL_APIENTRY GL_ProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0)
8123 {
8124 Context *context = GetValidGlobalContext();
8125 EVENT(context, GLProgramUniform1fEXT, "context = %d, program = %u, location = %d, v0 = %f",
8126 CID(context), program, location, v0);
8127
8128 if (context)
8129 {
8130 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8131 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8132 SCOPED_SHARE_CONTEXT_LOCK(context);
8133 bool isCallValid =
8134 (context->skipValidation() ||
8135 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8136 context->getMutableErrorSetForValidation(),
8137 angle::EntryPoint::GLProgramUniform1fEXT) &&
8138 ValidateProgramUniform1fEXT(context, angle::EntryPoint::GLProgramUniform1fEXT,
8139 programPacked, locationPacked, v0)));
8140 if (isCallValid)
8141 {
8142 context->programUniform1f(programPacked, locationPacked, v0);
8143 }
8144 ANGLE_CAPTURE_GL(ProgramUniform1fEXT, isCallValid, context, programPacked, locationPacked,
8145 v0);
8146 }
8147 else
8148 {
8149 GenerateContextLostErrorOnCurrentGlobalContext();
8150 }
8151 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8152 }
8153
GL_ProgramUniform1fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat * value)8154 void GL_APIENTRY GL_ProgramUniform1fvEXT(GLuint program,
8155 GLint location,
8156 GLsizei count,
8157 const GLfloat *value)
8158 {
8159 Context *context = GetValidGlobalContext();
8160 EVENT(context, GLProgramUniform1fvEXT,
8161 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
8162 CID(context), program, location, count, (uintptr_t)value);
8163
8164 if (context)
8165 {
8166 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8167 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8168 SCOPED_SHARE_CONTEXT_LOCK(context);
8169 bool isCallValid =
8170 (context->skipValidation() ||
8171 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8172 context->getMutableErrorSetForValidation(),
8173 angle::EntryPoint::GLProgramUniform1fvEXT) &&
8174 ValidateProgramUniform1fvEXT(context, angle::EntryPoint::GLProgramUniform1fvEXT,
8175 programPacked, locationPacked, count, value)));
8176 if (isCallValid)
8177 {
8178 context->programUniform1fv(programPacked, locationPacked, count, value);
8179 }
8180 ANGLE_CAPTURE_GL(ProgramUniform1fvEXT, isCallValid, context, programPacked, locationPacked,
8181 count, value);
8182 }
8183 else
8184 {
8185 GenerateContextLostErrorOnCurrentGlobalContext();
8186 }
8187 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8188 }
8189
GL_ProgramUniform1iEXT(GLuint program,GLint location,GLint v0)8190 void GL_APIENTRY GL_ProgramUniform1iEXT(GLuint program, GLint location, GLint v0)
8191 {
8192 Context *context = GetValidGlobalContext();
8193 EVENT(context, GLProgramUniform1iEXT, "context = %d, program = %u, location = %d, v0 = %d",
8194 CID(context), program, location, v0);
8195
8196 if (context)
8197 {
8198 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8199 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8200 SCOPED_SHARE_CONTEXT_LOCK(context);
8201 bool isCallValid =
8202 (context->skipValidation() ||
8203 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8204 context->getMutableErrorSetForValidation(),
8205 angle::EntryPoint::GLProgramUniform1iEXT) &&
8206 ValidateProgramUniform1iEXT(context, angle::EntryPoint::GLProgramUniform1iEXT,
8207 programPacked, locationPacked, v0)));
8208 if (isCallValid)
8209 {
8210 context->programUniform1i(programPacked, locationPacked, v0);
8211 }
8212 ANGLE_CAPTURE_GL(ProgramUniform1iEXT, isCallValid, context, programPacked, locationPacked,
8213 v0);
8214 }
8215 else
8216 {
8217 GenerateContextLostErrorOnCurrentGlobalContext();
8218 }
8219 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8220 }
8221
GL_ProgramUniform1ivEXT(GLuint program,GLint location,GLsizei count,const GLint * value)8222 void GL_APIENTRY GL_ProgramUniform1ivEXT(GLuint program,
8223 GLint location,
8224 GLsizei count,
8225 const GLint *value)
8226 {
8227 Context *context = GetValidGlobalContext();
8228 EVENT(context, GLProgramUniform1ivEXT,
8229 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
8230 CID(context), program, location, count, (uintptr_t)value);
8231
8232 if (context)
8233 {
8234 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8235 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8236 SCOPED_SHARE_CONTEXT_LOCK(context);
8237 bool isCallValid =
8238 (context->skipValidation() ||
8239 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8240 context->getMutableErrorSetForValidation(),
8241 angle::EntryPoint::GLProgramUniform1ivEXT) &&
8242 ValidateProgramUniform1ivEXT(context, angle::EntryPoint::GLProgramUniform1ivEXT,
8243 programPacked, locationPacked, count, value)));
8244 if (isCallValid)
8245 {
8246 context->programUniform1iv(programPacked, locationPacked, count, value);
8247 }
8248 ANGLE_CAPTURE_GL(ProgramUniform1ivEXT, isCallValid, context, programPacked, locationPacked,
8249 count, value);
8250 }
8251 else
8252 {
8253 GenerateContextLostErrorOnCurrentGlobalContext();
8254 }
8255 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8256 }
8257
GL_ProgramUniform1uiEXT(GLuint program,GLint location,GLuint v0)8258 void GL_APIENTRY GL_ProgramUniform1uiEXT(GLuint program, GLint location, GLuint v0)
8259 {
8260 Context *context = GetValidGlobalContext();
8261 EVENT(context, GLProgramUniform1uiEXT, "context = %d, program = %u, location = %d, v0 = %u",
8262 CID(context), program, location, v0);
8263
8264 if (context)
8265 {
8266 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8267 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8268 SCOPED_SHARE_CONTEXT_LOCK(context);
8269 bool isCallValid =
8270 (context->skipValidation() ||
8271 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8272 context->getMutableErrorSetForValidation(),
8273 angle::EntryPoint::GLProgramUniform1uiEXT) &&
8274 ValidateProgramUniform1uiEXT(context, angle::EntryPoint::GLProgramUniform1uiEXT,
8275 programPacked, locationPacked, v0)));
8276 if (isCallValid)
8277 {
8278 context->programUniform1ui(programPacked, locationPacked, v0);
8279 }
8280 ANGLE_CAPTURE_GL(ProgramUniform1uiEXT, isCallValid, context, programPacked, locationPacked,
8281 v0);
8282 }
8283 else
8284 {
8285 GenerateContextLostErrorOnCurrentGlobalContext();
8286 }
8287 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8288 }
8289
GL_ProgramUniform1uivEXT(GLuint program,GLint location,GLsizei count,const GLuint * value)8290 void GL_APIENTRY GL_ProgramUniform1uivEXT(GLuint program,
8291 GLint location,
8292 GLsizei count,
8293 const GLuint *value)
8294 {
8295 Context *context = GetValidGlobalContext();
8296 EVENT(context, GLProgramUniform1uivEXT,
8297 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
8298 CID(context), program, location, count, (uintptr_t)value);
8299
8300 if (context)
8301 {
8302 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8303 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8304 SCOPED_SHARE_CONTEXT_LOCK(context);
8305 bool isCallValid =
8306 (context->skipValidation() ||
8307 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8308 context->getMutableErrorSetForValidation(),
8309 angle::EntryPoint::GLProgramUniform1uivEXT) &&
8310 ValidateProgramUniform1uivEXT(context, angle::EntryPoint::GLProgramUniform1uivEXT,
8311 programPacked, locationPacked, count, value)));
8312 if (isCallValid)
8313 {
8314 context->programUniform1uiv(programPacked, locationPacked, count, value);
8315 }
8316 ANGLE_CAPTURE_GL(ProgramUniform1uivEXT, isCallValid, context, programPacked, locationPacked,
8317 count, value);
8318 }
8319 else
8320 {
8321 GenerateContextLostErrorOnCurrentGlobalContext();
8322 }
8323 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8324 }
8325
GL_ProgramUniform2fEXT(GLuint program,GLint location,GLfloat v0,GLfloat v1)8326 void GL_APIENTRY GL_ProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1)
8327 {
8328 Context *context = GetValidGlobalContext();
8329 EVENT(context, GLProgramUniform2fEXT,
8330 "context = %d, program = %u, location = %d, v0 = %f, v1 = %f", CID(context), program,
8331 location, v0, v1);
8332
8333 if (context)
8334 {
8335 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8336 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8337 SCOPED_SHARE_CONTEXT_LOCK(context);
8338 bool isCallValid =
8339 (context->skipValidation() ||
8340 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8341 context->getMutableErrorSetForValidation(),
8342 angle::EntryPoint::GLProgramUniform2fEXT) &&
8343 ValidateProgramUniform2fEXT(context, angle::EntryPoint::GLProgramUniform2fEXT,
8344 programPacked, locationPacked, v0, v1)));
8345 if (isCallValid)
8346 {
8347 context->programUniform2f(programPacked, locationPacked, v0, v1);
8348 }
8349 ANGLE_CAPTURE_GL(ProgramUniform2fEXT, isCallValid, context, programPacked, locationPacked,
8350 v0, v1);
8351 }
8352 else
8353 {
8354 GenerateContextLostErrorOnCurrentGlobalContext();
8355 }
8356 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8357 }
8358
GL_ProgramUniform2fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat * value)8359 void GL_APIENTRY GL_ProgramUniform2fvEXT(GLuint program,
8360 GLint location,
8361 GLsizei count,
8362 const GLfloat *value)
8363 {
8364 Context *context = GetValidGlobalContext();
8365 EVENT(context, GLProgramUniform2fvEXT,
8366 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
8367 CID(context), program, location, count, (uintptr_t)value);
8368
8369 if (context)
8370 {
8371 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8372 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8373 SCOPED_SHARE_CONTEXT_LOCK(context);
8374 bool isCallValid =
8375 (context->skipValidation() ||
8376 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8377 context->getMutableErrorSetForValidation(),
8378 angle::EntryPoint::GLProgramUniform2fvEXT) &&
8379 ValidateProgramUniform2fvEXT(context, angle::EntryPoint::GLProgramUniform2fvEXT,
8380 programPacked, locationPacked, count, value)));
8381 if (isCallValid)
8382 {
8383 context->programUniform2fv(programPacked, locationPacked, count, value);
8384 }
8385 ANGLE_CAPTURE_GL(ProgramUniform2fvEXT, isCallValid, context, programPacked, locationPacked,
8386 count, value);
8387 }
8388 else
8389 {
8390 GenerateContextLostErrorOnCurrentGlobalContext();
8391 }
8392 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8393 }
8394
GL_ProgramUniform2iEXT(GLuint program,GLint location,GLint v0,GLint v1)8395 void GL_APIENTRY GL_ProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1)
8396 {
8397 Context *context = GetValidGlobalContext();
8398 EVENT(context, GLProgramUniform2iEXT,
8399 "context = %d, program = %u, location = %d, v0 = %d, v1 = %d", CID(context), program,
8400 location, v0, v1);
8401
8402 if (context)
8403 {
8404 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8405 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8406 SCOPED_SHARE_CONTEXT_LOCK(context);
8407 bool isCallValid =
8408 (context->skipValidation() ||
8409 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8410 context->getMutableErrorSetForValidation(),
8411 angle::EntryPoint::GLProgramUniform2iEXT) &&
8412 ValidateProgramUniform2iEXT(context, angle::EntryPoint::GLProgramUniform2iEXT,
8413 programPacked, locationPacked, v0, v1)));
8414 if (isCallValid)
8415 {
8416 context->programUniform2i(programPacked, locationPacked, v0, v1);
8417 }
8418 ANGLE_CAPTURE_GL(ProgramUniform2iEXT, isCallValid, context, programPacked, locationPacked,
8419 v0, v1);
8420 }
8421 else
8422 {
8423 GenerateContextLostErrorOnCurrentGlobalContext();
8424 }
8425 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8426 }
8427
GL_ProgramUniform2ivEXT(GLuint program,GLint location,GLsizei count,const GLint * value)8428 void GL_APIENTRY GL_ProgramUniform2ivEXT(GLuint program,
8429 GLint location,
8430 GLsizei count,
8431 const GLint *value)
8432 {
8433 Context *context = GetValidGlobalContext();
8434 EVENT(context, GLProgramUniform2ivEXT,
8435 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
8436 CID(context), program, location, count, (uintptr_t)value);
8437
8438 if (context)
8439 {
8440 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8441 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8442 SCOPED_SHARE_CONTEXT_LOCK(context);
8443 bool isCallValid =
8444 (context->skipValidation() ||
8445 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8446 context->getMutableErrorSetForValidation(),
8447 angle::EntryPoint::GLProgramUniform2ivEXT) &&
8448 ValidateProgramUniform2ivEXT(context, angle::EntryPoint::GLProgramUniform2ivEXT,
8449 programPacked, locationPacked, count, value)));
8450 if (isCallValid)
8451 {
8452 context->programUniform2iv(programPacked, locationPacked, count, value);
8453 }
8454 ANGLE_CAPTURE_GL(ProgramUniform2ivEXT, isCallValid, context, programPacked, locationPacked,
8455 count, value);
8456 }
8457 else
8458 {
8459 GenerateContextLostErrorOnCurrentGlobalContext();
8460 }
8461 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8462 }
8463
GL_ProgramUniform2uiEXT(GLuint program,GLint location,GLuint v0,GLuint v1)8464 void GL_APIENTRY GL_ProgramUniform2uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1)
8465 {
8466 Context *context = GetValidGlobalContext();
8467 EVENT(context, GLProgramUniform2uiEXT,
8468 "context = %d, program = %u, location = %d, v0 = %u, v1 = %u", CID(context), program,
8469 location, v0, v1);
8470
8471 if (context)
8472 {
8473 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8474 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8475 SCOPED_SHARE_CONTEXT_LOCK(context);
8476 bool isCallValid =
8477 (context->skipValidation() ||
8478 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8479 context->getMutableErrorSetForValidation(),
8480 angle::EntryPoint::GLProgramUniform2uiEXT) &&
8481 ValidateProgramUniform2uiEXT(context, angle::EntryPoint::GLProgramUniform2uiEXT,
8482 programPacked, locationPacked, v0, v1)));
8483 if (isCallValid)
8484 {
8485 context->programUniform2ui(programPacked, locationPacked, v0, v1);
8486 }
8487 ANGLE_CAPTURE_GL(ProgramUniform2uiEXT, isCallValid, context, programPacked, locationPacked,
8488 v0, v1);
8489 }
8490 else
8491 {
8492 GenerateContextLostErrorOnCurrentGlobalContext();
8493 }
8494 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8495 }
8496
GL_ProgramUniform2uivEXT(GLuint program,GLint location,GLsizei count,const GLuint * value)8497 void GL_APIENTRY GL_ProgramUniform2uivEXT(GLuint program,
8498 GLint location,
8499 GLsizei count,
8500 const GLuint *value)
8501 {
8502 Context *context = GetValidGlobalContext();
8503 EVENT(context, GLProgramUniform2uivEXT,
8504 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
8505 CID(context), program, location, count, (uintptr_t)value);
8506
8507 if (context)
8508 {
8509 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8510 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8511 SCOPED_SHARE_CONTEXT_LOCK(context);
8512 bool isCallValid =
8513 (context->skipValidation() ||
8514 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8515 context->getMutableErrorSetForValidation(),
8516 angle::EntryPoint::GLProgramUniform2uivEXT) &&
8517 ValidateProgramUniform2uivEXT(context, angle::EntryPoint::GLProgramUniform2uivEXT,
8518 programPacked, locationPacked, count, value)));
8519 if (isCallValid)
8520 {
8521 context->programUniform2uiv(programPacked, locationPacked, count, value);
8522 }
8523 ANGLE_CAPTURE_GL(ProgramUniform2uivEXT, isCallValid, context, programPacked, locationPacked,
8524 count, value);
8525 }
8526 else
8527 {
8528 GenerateContextLostErrorOnCurrentGlobalContext();
8529 }
8530 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8531 }
8532
8533 void GL_APIENTRY
GL_ProgramUniform3fEXT(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2)8534 GL_ProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
8535 {
8536 Context *context = GetValidGlobalContext();
8537 EVENT(context, GLProgramUniform3fEXT,
8538 "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f", CID(context),
8539 program, location, v0, v1, v2);
8540
8541 if (context)
8542 {
8543 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8544 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8545 SCOPED_SHARE_CONTEXT_LOCK(context);
8546 bool isCallValid =
8547 (context->skipValidation() ||
8548 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8549 context->getMutableErrorSetForValidation(),
8550 angle::EntryPoint::GLProgramUniform3fEXT) &&
8551 ValidateProgramUniform3fEXT(context, angle::EntryPoint::GLProgramUniform3fEXT,
8552 programPacked, locationPacked, v0, v1, v2)));
8553 if (isCallValid)
8554 {
8555 context->programUniform3f(programPacked, locationPacked, v0, v1, v2);
8556 }
8557 ANGLE_CAPTURE_GL(ProgramUniform3fEXT, isCallValid, context, programPacked, locationPacked,
8558 v0, v1, v2);
8559 }
8560 else
8561 {
8562 GenerateContextLostErrorOnCurrentGlobalContext();
8563 }
8564 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8565 }
8566
GL_ProgramUniform3fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat * value)8567 void GL_APIENTRY GL_ProgramUniform3fvEXT(GLuint program,
8568 GLint location,
8569 GLsizei count,
8570 const GLfloat *value)
8571 {
8572 Context *context = GetValidGlobalContext();
8573 EVENT(context, GLProgramUniform3fvEXT,
8574 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
8575 CID(context), program, location, count, (uintptr_t)value);
8576
8577 if (context)
8578 {
8579 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8580 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8581 SCOPED_SHARE_CONTEXT_LOCK(context);
8582 bool isCallValid =
8583 (context->skipValidation() ||
8584 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8585 context->getMutableErrorSetForValidation(),
8586 angle::EntryPoint::GLProgramUniform3fvEXT) &&
8587 ValidateProgramUniform3fvEXT(context, angle::EntryPoint::GLProgramUniform3fvEXT,
8588 programPacked, locationPacked, count, value)));
8589 if (isCallValid)
8590 {
8591 context->programUniform3fv(programPacked, locationPacked, count, value);
8592 }
8593 ANGLE_CAPTURE_GL(ProgramUniform3fvEXT, isCallValid, context, programPacked, locationPacked,
8594 count, value);
8595 }
8596 else
8597 {
8598 GenerateContextLostErrorOnCurrentGlobalContext();
8599 }
8600 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8601 }
8602
8603 void GL_APIENTRY
GL_ProgramUniform3iEXT(GLuint program,GLint location,GLint v0,GLint v1,GLint v2)8604 GL_ProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
8605 {
8606 Context *context = GetValidGlobalContext();
8607 EVENT(context, GLProgramUniform3iEXT,
8608 "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d", CID(context),
8609 program, location, v0, v1, v2);
8610
8611 if (context)
8612 {
8613 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8614 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8615 SCOPED_SHARE_CONTEXT_LOCK(context);
8616 bool isCallValid =
8617 (context->skipValidation() ||
8618 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8619 context->getMutableErrorSetForValidation(),
8620 angle::EntryPoint::GLProgramUniform3iEXT) &&
8621 ValidateProgramUniform3iEXT(context, angle::EntryPoint::GLProgramUniform3iEXT,
8622 programPacked, locationPacked, v0, v1, v2)));
8623 if (isCallValid)
8624 {
8625 context->programUniform3i(programPacked, locationPacked, v0, v1, v2);
8626 }
8627 ANGLE_CAPTURE_GL(ProgramUniform3iEXT, isCallValid, context, programPacked, locationPacked,
8628 v0, v1, v2);
8629 }
8630 else
8631 {
8632 GenerateContextLostErrorOnCurrentGlobalContext();
8633 }
8634 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8635 }
8636
GL_ProgramUniform3ivEXT(GLuint program,GLint location,GLsizei count,const GLint * value)8637 void GL_APIENTRY GL_ProgramUniform3ivEXT(GLuint program,
8638 GLint location,
8639 GLsizei count,
8640 const GLint *value)
8641 {
8642 Context *context = GetValidGlobalContext();
8643 EVENT(context, GLProgramUniform3ivEXT,
8644 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
8645 CID(context), program, location, count, (uintptr_t)value);
8646
8647 if (context)
8648 {
8649 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8650 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8651 SCOPED_SHARE_CONTEXT_LOCK(context);
8652 bool isCallValid =
8653 (context->skipValidation() ||
8654 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8655 context->getMutableErrorSetForValidation(),
8656 angle::EntryPoint::GLProgramUniform3ivEXT) &&
8657 ValidateProgramUniform3ivEXT(context, angle::EntryPoint::GLProgramUniform3ivEXT,
8658 programPacked, locationPacked, count, value)));
8659 if (isCallValid)
8660 {
8661 context->programUniform3iv(programPacked, locationPacked, count, value);
8662 }
8663 ANGLE_CAPTURE_GL(ProgramUniform3ivEXT, isCallValid, context, programPacked, locationPacked,
8664 count, value);
8665 }
8666 else
8667 {
8668 GenerateContextLostErrorOnCurrentGlobalContext();
8669 }
8670 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8671 }
8672
8673 void GL_APIENTRY
GL_ProgramUniform3uiEXT(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2)8674 GL_ProgramUniform3uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
8675 {
8676 Context *context = GetValidGlobalContext();
8677 EVENT(context, GLProgramUniform3uiEXT,
8678 "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u", CID(context),
8679 program, location, v0, v1, v2);
8680
8681 if (context)
8682 {
8683 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8684 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8685 SCOPED_SHARE_CONTEXT_LOCK(context);
8686 bool isCallValid =
8687 (context->skipValidation() ||
8688 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8689 context->getMutableErrorSetForValidation(),
8690 angle::EntryPoint::GLProgramUniform3uiEXT) &&
8691 ValidateProgramUniform3uiEXT(context, angle::EntryPoint::GLProgramUniform3uiEXT,
8692 programPacked, locationPacked, v0, v1, v2)));
8693 if (isCallValid)
8694 {
8695 context->programUniform3ui(programPacked, locationPacked, v0, v1, v2);
8696 }
8697 ANGLE_CAPTURE_GL(ProgramUniform3uiEXT, isCallValid, context, programPacked, locationPacked,
8698 v0, v1, v2);
8699 }
8700 else
8701 {
8702 GenerateContextLostErrorOnCurrentGlobalContext();
8703 }
8704 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8705 }
8706
GL_ProgramUniform3uivEXT(GLuint program,GLint location,GLsizei count,const GLuint * value)8707 void GL_APIENTRY GL_ProgramUniform3uivEXT(GLuint program,
8708 GLint location,
8709 GLsizei count,
8710 const GLuint *value)
8711 {
8712 Context *context = GetValidGlobalContext();
8713 EVENT(context, GLProgramUniform3uivEXT,
8714 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
8715 CID(context), program, location, count, (uintptr_t)value);
8716
8717 if (context)
8718 {
8719 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8720 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8721 SCOPED_SHARE_CONTEXT_LOCK(context);
8722 bool isCallValid =
8723 (context->skipValidation() ||
8724 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8725 context->getMutableErrorSetForValidation(),
8726 angle::EntryPoint::GLProgramUniform3uivEXT) &&
8727 ValidateProgramUniform3uivEXT(context, angle::EntryPoint::GLProgramUniform3uivEXT,
8728 programPacked, locationPacked, count, value)));
8729 if (isCallValid)
8730 {
8731 context->programUniform3uiv(programPacked, locationPacked, count, value);
8732 }
8733 ANGLE_CAPTURE_GL(ProgramUniform3uivEXT, isCallValid, context, programPacked, locationPacked,
8734 count, value);
8735 }
8736 else
8737 {
8738 GenerateContextLostErrorOnCurrentGlobalContext();
8739 }
8740 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8741 }
8742
GL_ProgramUniform4fEXT(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)8743 void GL_APIENTRY GL_ProgramUniform4fEXT(GLuint program,
8744 GLint location,
8745 GLfloat v0,
8746 GLfloat v1,
8747 GLfloat v2,
8748 GLfloat v3)
8749 {
8750 Context *context = GetValidGlobalContext();
8751 EVENT(context, GLProgramUniform4fEXT,
8752 "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f",
8753 CID(context), program, location, v0, v1, v2, v3);
8754
8755 if (context)
8756 {
8757 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8758 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8759 SCOPED_SHARE_CONTEXT_LOCK(context);
8760 bool isCallValid =
8761 (context->skipValidation() ||
8762 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8763 context->getMutableErrorSetForValidation(),
8764 angle::EntryPoint::GLProgramUniform4fEXT) &&
8765 ValidateProgramUniform4fEXT(context, angle::EntryPoint::GLProgramUniform4fEXT,
8766 programPacked, locationPacked, v0, v1, v2, v3)));
8767 if (isCallValid)
8768 {
8769 context->programUniform4f(programPacked, locationPacked, v0, v1, v2, v3);
8770 }
8771 ANGLE_CAPTURE_GL(ProgramUniform4fEXT, isCallValid, context, programPacked, locationPacked,
8772 v0, v1, v2, v3);
8773 }
8774 else
8775 {
8776 GenerateContextLostErrorOnCurrentGlobalContext();
8777 }
8778 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8779 }
8780
GL_ProgramUniform4fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat * value)8781 void GL_APIENTRY GL_ProgramUniform4fvEXT(GLuint program,
8782 GLint location,
8783 GLsizei count,
8784 const GLfloat *value)
8785 {
8786 Context *context = GetValidGlobalContext();
8787 EVENT(context, GLProgramUniform4fvEXT,
8788 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
8789 CID(context), program, location, count, (uintptr_t)value);
8790
8791 if (context)
8792 {
8793 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8794 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8795 SCOPED_SHARE_CONTEXT_LOCK(context);
8796 bool isCallValid =
8797 (context->skipValidation() ||
8798 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8799 context->getMutableErrorSetForValidation(),
8800 angle::EntryPoint::GLProgramUniform4fvEXT) &&
8801 ValidateProgramUniform4fvEXT(context, angle::EntryPoint::GLProgramUniform4fvEXT,
8802 programPacked, locationPacked, count, value)));
8803 if (isCallValid)
8804 {
8805 context->programUniform4fv(programPacked, locationPacked, count, value);
8806 }
8807 ANGLE_CAPTURE_GL(ProgramUniform4fvEXT, isCallValid, context, programPacked, locationPacked,
8808 count, value);
8809 }
8810 else
8811 {
8812 GenerateContextLostErrorOnCurrentGlobalContext();
8813 }
8814 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8815 }
8816
8817 void GL_APIENTRY
GL_ProgramUniform4iEXT(GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3)8818 GL_ProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
8819 {
8820 Context *context = GetValidGlobalContext();
8821 EVENT(context, GLProgramUniform4iEXT,
8822 "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d, v3 = %d",
8823 CID(context), program, location, v0, v1, v2, v3);
8824
8825 if (context)
8826 {
8827 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8828 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8829 SCOPED_SHARE_CONTEXT_LOCK(context);
8830 bool isCallValid =
8831 (context->skipValidation() ||
8832 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8833 context->getMutableErrorSetForValidation(),
8834 angle::EntryPoint::GLProgramUniform4iEXT) &&
8835 ValidateProgramUniform4iEXT(context, angle::EntryPoint::GLProgramUniform4iEXT,
8836 programPacked, locationPacked, v0, v1, v2, v3)));
8837 if (isCallValid)
8838 {
8839 context->programUniform4i(programPacked, locationPacked, v0, v1, v2, v3);
8840 }
8841 ANGLE_CAPTURE_GL(ProgramUniform4iEXT, isCallValid, context, programPacked, locationPacked,
8842 v0, v1, v2, v3);
8843 }
8844 else
8845 {
8846 GenerateContextLostErrorOnCurrentGlobalContext();
8847 }
8848 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8849 }
8850
GL_ProgramUniform4ivEXT(GLuint program,GLint location,GLsizei count,const GLint * value)8851 void GL_APIENTRY GL_ProgramUniform4ivEXT(GLuint program,
8852 GLint location,
8853 GLsizei count,
8854 const GLint *value)
8855 {
8856 Context *context = GetValidGlobalContext();
8857 EVENT(context, GLProgramUniform4ivEXT,
8858 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
8859 CID(context), program, location, count, (uintptr_t)value);
8860
8861 if (context)
8862 {
8863 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8864 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8865 SCOPED_SHARE_CONTEXT_LOCK(context);
8866 bool isCallValid =
8867 (context->skipValidation() ||
8868 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8869 context->getMutableErrorSetForValidation(),
8870 angle::EntryPoint::GLProgramUniform4ivEXT) &&
8871 ValidateProgramUniform4ivEXT(context, angle::EntryPoint::GLProgramUniform4ivEXT,
8872 programPacked, locationPacked, count, value)));
8873 if (isCallValid)
8874 {
8875 context->programUniform4iv(programPacked, locationPacked, count, value);
8876 }
8877 ANGLE_CAPTURE_GL(ProgramUniform4ivEXT, isCallValid, context, programPacked, locationPacked,
8878 count, value);
8879 }
8880 else
8881 {
8882 GenerateContextLostErrorOnCurrentGlobalContext();
8883 }
8884 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8885 }
8886
8887 void GL_APIENTRY
GL_ProgramUniform4uiEXT(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)8888 GL_ProgramUniform4uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
8889 {
8890 Context *context = GetValidGlobalContext();
8891 EVENT(context, GLProgramUniform4uiEXT,
8892 "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u, v3 = %u",
8893 CID(context), program, location, v0, v1, v2, v3);
8894
8895 if (context)
8896 {
8897 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8898 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8899 SCOPED_SHARE_CONTEXT_LOCK(context);
8900 bool isCallValid =
8901 (context->skipValidation() ||
8902 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8903 context->getMutableErrorSetForValidation(),
8904 angle::EntryPoint::GLProgramUniform4uiEXT) &&
8905 ValidateProgramUniform4uiEXT(context, angle::EntryPoint::GLProgramUniform4uiEXT,
8906 programPacked, locationPacked, v0, v1, v2, v3)));
8907 if (isCallValid)
8908 {
8909 context->programUniform4ui(programPacked, locationPacked, v0, v1, v2, v3);
8910 }
8911 ANGLE_CAPTURE_GL(ProgramUniform4uiEXT, isCallValid, context, programPacked, locationPacked,
8912 v0, v1, v2, v3);
8913 }
8914 else
8915 {
8916 GenerateContextLostErrorOnCurrentGlobalContext();
8917 }
8918 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8919 }
8920
GL_ProgramUniform4uivEXT(GLuint program,GLint location,GLsizei count,const GLuint * value)8921 void GL_APIENTRY GL_ProgramUniform4uivEXT(GLuint program,
8922 GLint location,
8923 GLsizei count,
8924 const GLuint *value)
8925 {
8926 Context *context = GetValidGlobalContext();
8927 EVENT(context, GLProgramUniform4uivEXT,
8928 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
8929 CID(context), program, location, count, (uintptr_t)value);
8930
8931 if (context)
8932 {
8933 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8934 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8935 SCOPED_SHARE_CONTEXT_LOCK(context);
8936 bool isCallValid =
8937 (context->skipValidation() ||
8938 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8939 context->getMutableErrorSetForValidation(),
8940 angle::EntryPoint::GLProgramUniform4uivEXT) &&
8941 ValidateProgramUniform4uivEXT(context, angle::EntryPoint::GLProgramUniform4uivEXT,
8942 programPacked, locationPacked, count, value)));
8943 if (isCallValid)
8944 {
8945 context->programUniform4uiv(programPacked, locationPacked, count, value);
8946 }
8947 ANGLE_CAPTURE_GL(ProgramUniform4uivEXT, isCallValid, context, programPacked, locationPacked,
8948 count, value);
8949 }
8950 else
8951 {
8952 GenerateContextLostErrorOnCurrentGlobalContext();
8953 }
8954 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8955 }
8956
GL_ProgramUniformMatrix2fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)8957 void GL_APIENTRY GL_ProgramUniformMatrix2fvEXT(GLuint program,
8958 GLint location,
8959 GLsizei count,
8960 GLboolean transpose,
8961 const GLfloat *value)
8962 {
8963 Context *context = GetValidGlobalContext();
8964 EVENT(context, GLProgramUniformMatrix2fvEXT,
8965 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
8966 "0x%016" PRIxPTR "",
8967 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
8968
8969 if (context)
8970 {
8971 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
8972 UniformLocation locationPacked = PackParam<UniformLocation>(location);
8973 SCOPED_SHARE_CONTEXT_LOCK(context);
8974 bool isCallValid =
8975 (context->skipValidation() ||
8976 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
8977 context->getMutableErrorSetForValidation(),
8978 angle::EntryPoint::GLProgramUniformMatrix2fvEXT) &&
8979 ValidateProgramUniformMatrix2fvEXT(
8980 context, angle::EntryPoint::GLProgramUniformMatrix2fvEXT, programPacked,
8981 locationPacked, count, transpose, value)));
8982 if (isCallValid)
8983 {
8984 context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose,
8985 value);
8986 }
8987 ANGLE_CAPTURE_GL(ProgramUniformMatrix2fvEXT, isCallValid, context, programPacked,
8988 locationPacked, count, transpose, value);
8989 }
8990 else
8991 {
8992 GenerateContextLostErrorOnCurrentGlobalContext();
8993 }
8994 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
8995 }
8996
GL_ProgramUniformMatrix2x3fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)8997 void GL_APIENTRY GL_ProgramUniformMatrix2x3fvEXT(GLuint program,
8998 GLint location,
8999 GLsizei count,
9000 GLboolean transpose,
9001 const GLfloat *value)
9002 {
9003 Context *context = GetValidGlobalContext();
9004 EVENT(context, GLProgramUniformMatrix2x3fvEXT,
9005 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
9006 "0x%016" PRIxPTR "",
9007 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
9008
9009 if (context)
9010 {
9011 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
9012 UniformLocation locationPacked = PackParam<UniformLocation>(location);
9013 SCOPED_SHARE_CONTEXT_LOCK(context);
9014 bool isCallValid =
9015 (context->skipValidation() ||
9016 (ValidatePixelLocalStorageInactive(
9017 context->getPrivateState(), context->getMutableErrorSetForValidation(),
9018 angle::EntryPoint::GLProgramUniformMatrix2x3fvEXT) &&
9019 ValidateProgramUniformMatrix2x3fvEXT(
9020 context, angle::EntryPoint::GLProgramUniformMatrix2x3fvEXT, programPacked,
9021 locationPacked, count, transpose, value)));
9022 if (isCallValid)
9023 {
9024 context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose,
9025 value);
9026 }
9027 ANGLE_CAPTURE_GL(ProgramUniformMatrix2x3fvEXT, isCallValid, context, programPacked,
9028 locationPacked, count, transpose, value);
9029 }
9030 else
9031 {
9032 GenerateContextLostErrorOnCurrentGlobalContext();
9033 }
9034 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9035 }
9036
GL_ProgramUniformMatrix2x4fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)9037 void GL_APIENTRY GL_ProgramUniformMatrix2x4fvEXT(GLuint program,
9038 GLint location,
9039 GLsizei count,
9040 GLboolean transpose,
9041 const GLfloat *value)
9042 {
9043 Context *context = GetValidGlobalContext();
9044 EVENT(context, GLProgramUniformMatrix2x4fvEXT,
9045 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
9046 "0x%016" PRIxPTR "",
9047 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
9048
9049 if (context)
9050 {
9051 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
9052 UniformLocation locationPacked = PackParam<UniformLocation>(location);
9053 SCOPED_SHARE_CONTEXT_LOCK(context);
9054 bool isCallValid =
9055 (context->skipValidation() ||
9056 (ValidatePixelLocalStorageInactive(
9057 context->getPrivateState(), context->getMutableErrorSetForValidation(),
9058 angle::EntryPoint::GLProgramUniformMatrix2x4fvEXT) &&
9059 ValidateProgramUniformMatrix2x4fvEXT(
9060 context, angle::EntryPoint::GLProgramUniformMatrix2x4fvEXT, programPacked,
9061 locationPacked, count, transpose, value)));
9062 if (isCallValid)
9063 {
9064 context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose,
9065 value);
9066 }
9067 ANGLE_CAPTURE_GL(ProgramUniformMatrix2x4fvEXT, isCallValid, context, programPacked,
9068 locationPacked, count, transpose, value);
9069 }
9070 else
9071 {
9072 GenerateContextLostErrorOnCurrentGlobalContext();
9073 }
9074 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9075 }
9076
GL_ProgramUniformMatrix3fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)9077 void GL_APIENTRY GL_ProgramUniformMatrix3fvEXT(GLuint program,
9078 GLint location,
9079 GLsizei count,
9080 GLboolean transpose,
9081 const GLfloat *value)
9082 {
9083 Context *context = GetValidGlobalContext();
9084 EVENT(context, GLProgramUniformMatrix3fvEXT,
9085 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
9086 "0x%016" PRIxPTR "",
9087 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
9088
9089 if (context)
9090 {
9091 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
9092 UniformLocation locationPacked = PackParam<UniformLocation>(location);
9093 SCOPED_SHARE_CONTEXT_LOCK(context);
9094 bool isCallValid =
9095 (context->skipValidation() ||
9096 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9097 context->getMutableErrorSetForValidation(),
9098 angle::EntryPoint::GLProgramUniformMatrix3fvEXT) &&
9099 ValidateProgramUniformMatrix3fvEXT(
9100 context, angle::EntryPoint::GLProgramUniformMatrix3fvEXT, programPacked,
9101 locationPacked, count, transpose, value)));
9102 if (isCallValid)
9103 {
9104 context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose,
9105 value);
9106 }
9107 ANGLE_CAPTURE_GL(ProgramUniformMatrix3fvEXT, isCallValid, context, programPacked,
9108 locationPacked, count, transpose, value);
9109 }
9110 else
9111 {
9112 GenerateContextLostErrorOnCurrentGlobalContext();
9113 }
9114 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9115 }
9116
GL_ProgramUniformMatrix3x2fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)9117 void GL_APIENTRY GL_ProgramUniformMatrix3x2fvEXT(GLuint program,
9118 GLint location,
9119 GLsizei count,
9120 GLboolean transpose,
9121 const GLfloat *value)
9122 {
9123 Context *context = GetValidGlobalContext();
9124 EVENT(context, GLProgramUniformMatrix3x2fvEXT,
9125 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
9126 "0x%016" PRIxPTR "",
9127 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
9128
9129 if (context)
9130 {
9131 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
9132 UniformLocation locationPacked = PackParam<UniformLocation>(location);
9133 SCOPED_SHARE_CONTEXT_LOCK(context);
9134 bool isCallValid =
9135 (context->skipValidation() ||
9136 (ValidatePixelLocalStorageInactive(
9137 context->getPrivateState(), context->getMutableErrorSetForValidation(),
9138 angle::EntryPoint::GLProgramUniformMatrix3x2fvEXT) &&
9139 ValidateProgramUniformMatrix3x2fvEXT(
9140 context, angle::EntryPoint::GLProgramUniformMatrix3x2fvEXT, programPacked,
9141 locationPacked, count, transpose, value)));
9142 if (isCallValid)
9143 {
9144 context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose,
9145 value);
9146 }
9147 ANGLE_CAPTURE_GL(ProgramUniformMatrix3x2fvEXT, isCallValid, context, programPacked,
9148 locationPacked, count, transpose, value);
9149 }
9150 else
9151 {
9152 GenerateContextLostErrorOnCurrentGlobalContext();
9153 }
9154 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9155 }
9156
GL_ProgramUniformMatrix3x4fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)9157 void GL_APIENTRY GL_ProgramUniformMatrix3x4fvEXT(GLuint program,
9158 GLint location,
9159 GLsizei count,
9160 GLboolean transpose,
9161 const GLfloat *value)
9162 {
9163 Context *context = GetValidGlobalContext();
9164 EVENT(context, GLProgramUniformMatrix3x4fvEXT,
9165 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
9166 "0x%016" PRIxPTR "",
9167 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
9168
9169 if (context)
9170 {
9171 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
9172 UniformLocation locationPacked = PackParam<UniformLocation>(location);
9173 SCOPED_SHARE_CONTEXT_LOCK(context);
9174 bool isCallValid =
9175 (context->skipValidation() ||
9176 (ValidatePixelLocalStorageInactive(
9177 context->getPrivateState(), context->getMutableErrorSetForValidation(),
9178 angle::EntryPoint::GLProgramUniformMatrix3x4fvEXT) &&
9179 ValidateProgramUniformMatrix3x4fvEXT(
9180 context, angle::EntryPoint::GLProgramUniformMatrix3x4fvEXT, programPacked,
9181 locationPacked, count, transpose, value)));
9182 if (isCallValid)
9183 {
9184 context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose,
9185 value);
9186 }
9187 ANGLE_CAPTURE_GL(ProgramUniformMatrix3x4fvEXT, isCallValid, context, programPacked,
9188 locationPacked, count, transpose, value);
9189 }
9190 else
9191 {
9192 GenerateContextLostErrorOnCurrentGlobalContext();
9193 }
9194 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9195 }
9196
GL_ProgramUniformMatrix4fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)9197 void GL_APIENTRY GL_ProgramUniformMatrix4fvEXT(GLuint program,
9198 GLint location,
9199 GLsizei count,
9200 GLboolean transpose,
9201 const GLfloat *value)
9202 {
9203 Context *context = GetValidGlobalContext();
9204 EVENT(context, GLProgramUniformMatrix4fvEXT,
9205 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
9206 "0x%016" PRIxPTR "",
9207 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
9208
9209 if (context)
9210 {
9211 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
9212 UniformLocation locationPacked = PackParam<UniformLocation>(location);
9213 SCOPED_SHARE_CONTEXT_LOCK(context);
9214 bool isCallValid =
9215 (context->skipValidation() ||
9216 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9217 context->getMutableErrorSetForValidation(),
9218 angle::EntryPoint::GLProgramUniformMatrix4fvEXT) &&
9219 ValidateProgramUniformMatrix4fvEXT(
9220 context, angle::EntryPoint::GLProgramUniformMatrix4fvEXT, programPacked,
9221 locationPacked, count, transpose, value)));
9222 if (isCallValid)
9223 {
9224 context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose,
9225 value);
9226 }
9227 ANGLE_CAPTURE_GL(ProgramUniformMatrix4fvEXT, isCallValid, context, programPacked,
9228 locationPacked, count, transpose, value);
9229 }
9230 else
9231 {
9232 GenerateContextLostErrorOnCurrentGlobalContext();
9233 }
9234 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9235 }
9236
GL_ProgramUniformMatrix4x2fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)9237 void GL_APIENTRY GL_ProgramUniformMatrix4x2fvEXT(GLuint program,
9238 GLint location,
9239 GLsizei count,
9240 GLboolean transpose,
9241 const GLfloat *value)
9242 {
9243 Context *context = GetValidGlobalContext();
9244 EVENT(context, GLProgramUniformMatrix4x2fvEXT,
9245 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
9246 "0x%016" PRIxPTR "",
9247 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
9248
9249 if (context)
9250 {
9251 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
9252 UniformLocation locationPacked = PackParam<UniformLocation>(location);
9253 SCOPED_SHARE_CONTEXT_LOCK(context);
9254 bool isCallValid =
9255 (context->skipValidation() ||
9256 (ValidatePixelLocalStorageInactive(
9257 context->getPrivateState(), context->getMutableErrorSetForValidation(),
9258 angle::EntryPoint::GLProgramUniformMatrix4x2fvEXT) &&
9259 ValidateProgramUniformMatrix4x2fvEXT(
9260 context, angle::EntryPoint::GLProgramUniformMatrix4x2fvEXT, programPacked,
9261 locationPacked, count, transpose, value)));
9262 if (isCallValid)
9263 {
9264 context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose,
9265 value);
9266 }
9267 ANGLE_CAPTURE_GL(ProgramUniformMatrix4x2fvEXT, isCallValid, context, programPacked,
9268 locationPacked, count, transpose, value);
9269 }
9270 else
9271 {
9272 GenerateContextLostErrorOnCurrentGlobalContext();
9273 }
9274 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9275 }
9276
GL_ProgramUniformMatrix4x3fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)9277 void GL_APIENTRY GL_ProgramUniformMatrix4x3fvEXT(GLuint program,
9278 GLint location,
9279 GLsizei count,
9280 GLboolean transpose,
9281 const GLfloat *value)
9282 {
9283 Context *context = GetValidGlobalContext();
9284 EVENT(context, GLProgramUniformMatrix4x3fvEXT,
9285 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
9286 "0x%016" PRIxPTR "",
9287 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
9288
9289 if (context)
9290 {
9291 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
9292 UniformLocation locationPacked = PackParam<UniformLocation>(location);
9293 SCOPED_SHARE_CONTEXT_LOCK(context);
9294 bool isCallValid =
9295 (context->skipValidation() ||
9296 (ValidatePixelLocalStorageInactive(
9297 context->getPrivateState(), context->getMutableErrorSetForValidation(),
9298 angle::EntryPoint::GLProgramUniformMatrix4x3fvEXT) &&
9299 ValidateProgramUniformMatrix4x3fvEXT(
9300 context, angle::EntryPoint::GLProgramUniformMatrix4x3fvEXT, programPacked,
9301 locationPacked, count, transpose, value)));
9302 if (isCallValid)
9303 {
9304 context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose,
9305 value);
9306 }
9307 ANGLE_CAPTURE_GL(ProgramUniformMatrix4x3fvEXT, isCallValid, context, programPacked,
9308 locationPacked, count, transpose, value);
9309 }
9310 else
9311 {
9312 GenerateContextLostErrorOnCurrentGlobalContext();
9313 }
9314 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9315 }
9316
GL_UseProgramStagesEXT(GLuint pipeline,GLbitfield stages,GLuint program)9317 void GL_APIENTRY GL_UseProgramStagesEXT(GLuint pipeline, GLbitfield stages, GLuint program)
9318 {
9319 Context *context = GetValidGlobalContext();
9320 EVENT(context, GLUseProgramStagesEXT, "context = %d, pipeline = %u, stages = %s, program = %u",
9321 CID(context), pipeline, GLbitfieldToString(GLESEnum::UseProgramStageMask, stages).c_str(),
9322 program);
9323
9324 if (context)
9325 {
9326 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
9327 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
9328 SCOPED_SHARE_CONTEXT_LOCK(context);
9329 bool isCallValid =
9330 (context->skipValidation() ||
9331 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9332 context->getMutableErrorSetForValidation(),
9333 angle::EntryPoint::GLUseProgramStagesEXT) &&
9334 ValidateUseProgramStagesEXT(context, angle::EntryPoint::GLUseProgramStagesEXT,
9335 pipelinePacked, stages, programPacked)));
9336 if (isCallValid)
9337 {
9338 context->useProgramStages(pipelinePacked, stages, programPacked);
9339 }
9340 ANGLE_CAPTURE_GL(UseProgramStagesEXT, isCallValid, context, pipelinePacked, stages,
9341 programPacked);
9342 }
9343 else
9344 {
9345 GenerateContextLostErrorOnCurrentGlobalContext();
9346 }
9347 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9348 }
9349
GL_ValidateProgramPipelineEXT(GLuint pipeline)9350 void GL_APIENTRY GL_ValidateProgramPipelineEXT(GLuint pipeline)
9351 {
9352 Context *context = GetValidGlobalContext();
9353 EVENT(context, GLValidateProgramPipelineEXT, "context = %d, pipeline = %u", CID(context),
9354 pipeline);
9355
9356 if (context)
9357 {
9358 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
9359 SCOPED_SHARE_CONTEXT_LOCK(context);
9360 bool isCallValid =
9361 (context->skipValidation() ||
9362 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9363 context->getMutableErrorSetForValidation(),
9364 angle::EntryPoint::GLValidateProgramPipelineEXT) &&
9365 ValidateValidateProgramPipelineEXT(
9366 context, angle::EntryPoint::GLValidateProgramPipelineEXT, pipelinePacked)));
9367 if (isCallValid)
9368 {
9369 context->validateProgramPipeline(pipelinePacked);
9370 }
9371 ANGLE_CAPTURE_GL(ValidateProgramPipelineEXT, isCallValid, context, pipelinePacked);
9372 }
9373 else
9374 {
9375 GenerateContextLostErrorOnCurrentGlobalContext();
9376 }
9377 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9378 }
9379
9380 // GL_EXT_shader_framebuffer_fetch
9381
9382 // GL_EXT_shader_framebuffer_fetch_non_coherent
GL_FramebufferFetchBarrierEXT()9383 void GL_APIENTRY GL_FramebufferFetchBarrierEXT()
9384 {
9385 Context *context = GetValidGlobalContext();
9386 EVENT(context, GLFramebufferFetchBarrierEXT, "context = %d", CID(context));
9387
9388 if (context)
9389 {
9390 SCOPED_SHARE_CONTEXT_LOCK(context);
9391 bool isCallValid =
9392 (context->skipValidation() ||
9393 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9394 context->getMutableErrorSetForValidation(),
9395 angle::EntryPoint::GLFramebufferFetchBarrierEXT) &&
9396 ValidateFramebufferFetchBarrierEXT(context,
9397 angle::EntryPoint::GLFramebufferFetchBarrierEXT)));
9398 if (isCallValid)
9399 {
9400 context->framebufferFetchBarrier();
9401 }
9402 ANGLE_CAPTURE_GL(FramebufferFetchBarrierEXT, isCallValid, context);
9403 }
9404 else
9405 {
9406 GenerateContextLostErrorOnCurrentGlobalContext();
9407 }
9408 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9409 }
9410
9411 // GL_EXT_shader_io_blocks
9412
9413 // GL_EXT_shader_non_constant_global_initializers
9414
9415 // GL_EXT_shader_texture_lod
9416
9417 // GL_EXT_shadow_samplers
9418
9419 // GL_EXT_tessellation_shader
GL_PatchParameteriEXT(GLenum pname,GLint value)9420 void GL_APIENTRY GL_PatchParameteriEXT(GLenum pname, GLint value)
9421 {
9422 Context *context = GetValidGlobalContext();
9423 EVENT(context, GLPatchParameteriEXT, "context = %d, pname = %s, value = %d", CID(context),
9424 GLenumToString(GLESEnum::PatchParameterName, pname), value);
9425
9426 if (context)
9427 {
9428 bool isCallValid =
9429 (context->skipValidation() ||
9430 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9431 context->getMutableErrorSetForValidation(),
9432 angle::EntryPoint::GLPatchParameteriEXT) &&
9433 ValidatePatchParameteriEXT(context->getPrivateState(),
9434 context->getMutableErrorSetForValidation(),
9435 angle::EntryPoint::GLPatchParameteriEXT, pname, value)));
9436 if (isCallValid)
9437 {
9438 ContextPrivatePatchParameteri(context->getMutablePrivateState(),
9439 context->getMutablePrivateStateCache(), pname, value);
9440 }
9441 ANGLE_CAPTURE_GL(PatchParameteriEXT, isCallValid, context, pname, value);
9442 }
9443 else
9444 {
9445 GenerateContextLostErrorOnCurrentGlobalContext();
9446 }
9447 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9448 }
9449
9450 // GL_EXT_texture_border_clamp
GL_GetSamplerParameterIivEXT(GLuint sampler,GLenum pname,GLint * params)9451 void GL_APIENTRY GL_GetSamplerParameterIivEXT(GLuint sampler, GLenum pname, GLint *params)
9452 {
9453 Context *context = GetValidGlobalContext();
9454 EVENT(context, GLGetSamplerParameterIivEXT,
9455 "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
9456 sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params);
9457
9458 if (context)
9459 {
9460 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
9461 SCOPED_SHARE_CONTEXT_LOCK(context);
9462 bool isCallValid = (context->skipValidation() ||
9463 ValidateGetSamplerParameterIivEXT(
9464 context, angle::EntryPoint::GLGetSamplerParameterIivEXT,
9465 samplerPacked, pname, params));
9466 if (isCallValid)
9467 {
9468 context->getSamplerParameterIiv(samplerPacked, pname, params);
9469 }
9470 ANGLE_CAPTURE_GL(GetSamplerParameterIivEXT, isCallValid, context, samplerPacked, pname,
9471 params);
9472 }
9473 else
9474 {
9475 GenerateContextLostErrorOnCurrentGlobalContext();
9476 }
9477 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9478 }
9479
GL_GetSamplerParameterIuivEXT(GLuint sampler,GLenum pname,GLuint * params)9480 void GL_APIENTRY GL_GetSamplerParameterIuivEXT(GLuint sampler, GLenum pname, GLuint *params)
9481 {
9482 Context *context = GetValidGlobalContext();
9483 EVENT(context, GLGetSamplerParameterIuivEXT,
9484 "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
9485 sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params);
9486
9487 if (context)
9488 {
9489 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
9490 SCOPED_SHARE_CONTEXT_LOCK(context);
9491 bool isCallValid = (context->skipValidation() ||
9492 ValidateGetSamplerParameterIuivEXT(
9493 context, angle::EntryPoint::GLGetSamplerParameterIuivEXT,
9494 samplerPacked, pname, params));
9495 if (isCallValid)
9496 {
9497 context->getSamplerParameterIuiv(samplerPacked, pname, params);
9498 }
9499 ANGLE_CAPTURE_GL(GetSamplerParameterIuivEXT, isCallValid, context, samplerPacked, pname,
9500 params);
9501 }
9502 else
9503 {
9504 GenerateContextLostErrorOnCurrentGlobalContext();
9505 }
9506 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9507 }
9508
GL_GetTexParameterIivEXT(GLenum target,GLenum pname,GLint * params)9509 void GL_APIENTRY GL_GetTexParameterIivEXT(GLenum target, GLenum pname, GLint *params)
9510 {
9511 Context *context = GetValidGlobalContext();
9512 EVENT(context, GLGetTexParameterIivEXT,
9513 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
9514 GLenumToString(GLESEnum::TextureTarget, target),
9515 GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params);
9516
9517 if (context)
9518 {
9519 TextureType targetPacked = PackParam<TextureType>(target);
9520 SCOPED_SHARE_CONTEXT_LOCK(context);
9521 bool isCallValid =
9522 (context->skipValidation() ||
9523 ValidateGetTexParameterIivEXT(context, angle::EntryPoint::GLGetTexParameterIivEXT,
9524 targetPacked, pname, params));
9525 if (isCallValid)
9526 {
9527 context->getTexParameterIiv(targetPacked, pname, params);
9528 }
9529 ANGLE_CAPTURE_GL(GetTexParameterIivEXT, isCallValid, context, targetPacked, pname, params);
9530 }
9531 else
9532 {
9533 GenerateContextLostErrorOnCurrentGlobalContext();
9534 }
9535 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9536 }
9537
GL_GetTexParameterIuivEXT(GLenum target,GLenum pname,GLuint * params)9538 void GL_APIENTRY GL_GetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint *params)
9539 {
9540 Context *context = GetValidGlobalContext();
9541 EVENT(context, GLGetTexParameterIuivEXT,
9542 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
9543 GLenumToString(GLESEnum::TextureTarget, target),
9544 GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params);
9545
9546 if (context)
9547 {
9548 TextureType targetPacked = PackParam<TextureType>(target);
9549 SCOPED_SHARE_CONTEXT_LOCK(context);
9550 bool isCallValid =
9551 (context->skipValidation() ||
9552 ValidateGetTexParameterIuivEXT(context, angle::EntryPoint::GLGetTexParameterIuivEXT,
9553 targetPacked, pname, params));
9554 if (isCallValid)
9555 {
9556 context->getTexParameterIuiv(targetPacked, pname, params);
9557 }
9558 ANGLE_CAPTURE_GL(GetTexParameterIuivEXT, isCallValid, context, targetPacked, pname, params);
9559 }
9560 else
9561 {
9562 GenerateContextLostErrorOnCurrentGlobalContext();
9563 }
9564 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9565 }
9566
GL_SamplerParameterIivEXT(GLuint sampler,GLenum pname,const GLint * param)9567 void GL_APIENTRY GL_SamplerParameterIivEXT(GLuint sampler, GLenum pname, const GLint *param)
9568 {
9569 Context *context = GetValidGlobalContext();
9570 EVENT(context, GLSamplerParameterIivEXT,
9571 "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
9572 sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param);
9573
9574 if (context)
9575 {
9576 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
9577 SCOPED_SHARE_CONTEXT_LOCK(context);
9578 bool isCallValid =
9579 (context->skipValidation() ||
9580 ValidateSamplerParameterIivEXT(context, angle::EntryPoint::GLSamplerParameterIivEXT,
9581 samplerPacked, pname, param));
9582 if (isCallValid)
9583 {
9584 context->samplerParameterIiv(samplerPacked, pname, param);
9585 }
9586 ANGLE_CAPTURE_GL(SamplerParameterIivEXT, isCallValid, context, samplerPacked, pname, param);
9587 }
9588 else
9589 {
9590 GenerateContextLostErrorOnCurrentGlobalContext();
9591 }
9592 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9593 }
9594
GL_SamplerParameterIuivEXT(GLuint sampler,GLenum pname,const GLuint * param)9595 void GL_APIENTRY GL_SamplerParameterIuivEXT(GLuint sampler, GLenum pname, const GLuint *param)
9596 {
9597 Context *context = GetValidGlobalContext();
9598 EVENT(context, GLSamplerParameterIuivEXT,
9599 "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
9600 sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param);
9601
9602 if (context)
9603 {
9604 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
9605 SCOPED_SHARE_CONTEXT_LOCK(context);
9606 bool isCallValid =
9607 (context->skipValidation() ||
9608 ValidateSamplerParameterIuivEXT(context, angle::EntryPoint::GLSamplerParameterIuivEXT,
9609 samplerPacked, pname, param));
9610 if (isCallValid)
9611 {
9612 context->samplerParameterIuiv(samplerPacked, pname, param);
9613 }
9614 ANGLE_CAPTURE_GL(SamplerParameterIuivEXT, isCallValid, context, samplerPacked, pname,
9615 param);
9616 }
9617 else
9618 {
9619 GenerateContextLostErrorOnCurrentGlobalContext();
9620 }
9621 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9622 }
9623
GL_TexParameterIivEXT(GLenum target,GLenum pname,const GLint * params)9624 void GL_APIENTRY GL_TexParameterIivEXT(GLenum target, GLenum pname, const GLint *params)
9625 {
9626 Context *context = GetValidGlobalContext();
9627 EVENT(context, GLTexParameterIivEXT,
9628 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
9629 GLenumToString(GLESEnum::TextureTarget, target),
9630 GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params);
9631
9632 if (context)
9633 {
9634 TextureType targetPacked = PackParam<TextureType>(target);
9635 SCOPED_SHARE_CONTEXT_LOCK(context);
9636 bool isCallValid =
9637 (context->skipValidation() ||
9638 ValidateTexParameterIivEXT(context, angle::EntryPoint::GLTexParameterIivEXT,
9639 targetPacked, pname, params));
9640 if (isCallValid)
9641 {
9642 context->texParameterIiv(targetPacked, pname, params);
9643 }
9644 ANGLE_CAPTURE_GL(TexParameterIivEXT, isCallValid, context, targetPacked, pname, params);
9645 }
9646 else
9647 {
9648 GenerateContextLostErrorOnCurrentGlobalContext();
9649 }
9650 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9651 }
9652
GL_TexParameterIuivEXT(GLenum target,GLenum pname,const GLuint * params)9653 void GL_APIENTRY GL_TexParameterIuivEXT(GLenum target, GLenum pname, const GLuint *params)
9654 {
9655 Context *context = GetValidGlobalContext();
9656 EVENT(context, GLTexParameterIuivEXT,
9657 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
9658 GLenumToString(GLESEnum::TextureTarget, target),
9659 GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params);
9660
9661 if (context)
9662 {
9663 TextureType targetPacked = PackParam<TextureType>(target);
9664 SCOPED_SHARE_CONTEXT_LOCK(context);
9665 bool isCallValid =
9666 (context->skipValidation() ||
9667 ValidateTexParameterIuivEXT(context, angle::EntryPoint::GLTexParameterIuivEXT,
9668 targetPacked, pname, params));
9669 if (isCallValid)
9670 {
9671 context->texParameterIuiv(targetPacked, pname, params);
9672 }
9673 ANGLE_CAPTURE_GL(TexParameterIuivEXT, isCallValid, context, targetPacked, pname, params);
9674 }
9675 else
9676 {
9677 GenerateContextLostErrorOnCurrentGlobalContext();
9678 }
9679 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9680 }
9681
9682 // GL_EXT_texture_buffer
GL_TexBufferEXT(GLenum target,GLenum internalformat,GLuint buffer)9683 void GL_APIENTRY GL_TexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer)
9684 {
9685 Context *context = GetValidGlobalContext();
9686 EVENT(context, GLTexBufferEXT, "context = %d, target = %s, internalformat = %s, buffer = %u",
9687 CID(context), GLenumToString(GLESEnum::TextureTarget, target),
9688 GLenumToString(GLESEnum::SizedInternalFormat, internalformat), buffer);
9689
9690 if (context)
9691 {
9692 TextureType targetPacked = PackParam<TextureType>(target);
9693 BufferID bufferPacked = PackParam<BufferID>(buffer);
9694 SCOPED_SHARE_CONTEXT_LOCK(context);
9695 bool isCallValid =
9696 (context->skipValidation() ||
9697 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9698 context->getMutableErrorSetForValidation(),
9699 angle::EntryPoint::GLTexBufferEXT) &&
9700 ValidateTexBufferEXT(context, angle::EntryPoint::GLTexBufferEXT, targetPacked,
9701 internalformat, bufferPacked)));
9702 if (isCallValid)
9703 {
9704 context->texBuffer(targetPacked, internalformat, bufferPacked);
9705 }
9706 ANGLE_CAPTURE_GL(TexBufferEXT, isCallValid, context, targetPacked, internalformat,
9707 bufferPacked);
9708 }
9709 else
9710 {
9711 GenerateContextLostErrorOnCurrentGlobalContext();
9712 }
9713 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9714 }
9715
GL_TexBufferRangeEXT(GLenum target,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size)9716 void GL_APIENTRY GL_TexBufferRangeEXT(GLenum target,
9717 GLenum internalformat,
9718 GLuint buffer,
9719 GLintptr offset,
9720 GLsizeiptr size)
9721 {
9722 Context *context = GetValidGlobalContext();
9723 EVENT(context, GLTexBufferRangeEXT,
9724 "context = %d, target = %s, internalformat = %s, buffer = %u, offset = %llu, size = %llu",
9725 CID(context), GLenumToString(GLESEnum::TextureTarget, target),
9726 GLenumToString(GLESEnum::SizedInternalFormat, internalformat), buffer,
9727 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size));
9728
9729 if (context)
9730 {
9731 TextureType targetPacked = PackParam<TextureType>(target);
9732 BufferID bufferPacked = PackParam<BufferID>(buffer);
9733 SCOPED_SHARE_CONTEXT_LOCK(context);
9734 bool isCallValid =
9735 (context->skipValidation() ||
9736 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9737 context->getMutableErrorSetForValidation(),
9738 angle::EntryPoint::GLTexBufferRangeEXT) &&
9739 ValidateTexBufferRangeEXT(context, angle::EntryPoint::GLTexBufferRangeEXT,
9740 targetPacked, internalformat, bufferPacked, offset, size)));
9741 if (isCallValid)
9742 {
9743 context->texBufferRange(targetPacked, internalformat, bufferPacked, offset, size);
9744 }
9745 ANGLE_CAPTURE_GL(TexBufferRangeEXT, isCallValid, context, targetPacked, internalformat,
9746 bufferPacked, offset, size);
9747 }
9748 else
9749 {
9750 GenerateContextLostErrorOnCurrentGlobalContext();
9751 }
9752 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9753 }
9754
9755 // GL_EXT_texture_compression_astc_decode_mode
9756
9757 // GL_EXT_texture_compression_bptc
9758
9759 // GL_EXT_texture_compression_dxt1
9760
9761 // GL_EXT_texture_compression_rgtc
9762
9763 // GL_EXT_texture_compression_s3tc
9764
9765 // GL_EXT_texture_compression_s3tc_srgb
9766
9767 // GL_EXT_texture_cube_map_array
9768
9769 // GL_EXT_texture_filter_anisotropic
9770
9771 // GL_EXT_texture_filter_minmax
9772
9773 // GL_EXT_texture_format_BGRA8888
9774
9775 // GL_EXT_texture_format_sRGB_override
9776
9777 // GL_EXT_texture_mirror_clamp_to_edge
9778
9779 // GL_EXT_texture_norm16
9780
9781 // GL_EXT_texture_rg
9782
9783 // GL_EXT_texture_sRGB_R8
9784
9785 // GL_EXT_texture_sRGB_RG8
9786
9787 // GL_EXT_texture_sRGB_decode
9788
9789 // GL_EXT_texture_storage
GL_TexStorage1DEXT(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width)9790 void GL_APIENTRY GL_TexStorage1DEXT(GLenum target,
9791 GLsizei levels,
9792 GLenum internalformat,
9793 GLsizei width)
9794 {
9795 Context *context = GetValidGlobalContext();
9796 EVENT(context, GLTexStorage1DEXT,
9797 "context = %d, target = %s, levels = %d, internalformat = %s, width = %d", CID(context),
9798 GLenumToString(GLESEnum::TextureTarget, target), levels,
9799 GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width);
9800
9801 if (context)
9802 {
9803 SCOPED_SHARE_CONTEXT_LOCK(context);
9804 bool isCallValid =
9805 (context->skipValidation() ||
9806 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9807 context->getMutableErrorSetForValidation(),
9808 angle::EntryPoint::GLTexStorage1DEXT) &&
9809 ValidateTexStorage1DEXT(context, angle::EntryPoint::GLTexStorage1DEXT, target, levels,
9810 internalformat, width)));
9811 if (isCallValid)
9812 {
9813 context->texStorage1D(target, levels, internalformat, width);
9814 }
9815 ANGLE_CAPTURE_GL(TexStorage1DEXT, isCallValid, context, target, levels, internalformat,
9816 width);
9817 }
9818 else
9819 {
9820 GenerateContextLostErrorOnCurrentGlobalContext();
9821 }
9822 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9823 }
9824
GL_TexStorage2DEXT(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)9825 void GL_APIENTRY GL_TexStorage2DEXT(GLenum target,
9826 GLsizei levels,
9827 GLenum internalformat,
9828 GLsizei width,
9829 GLsizei height)
9830 {
9831 Context *context = GetValidGlobalContext();
9832 EVENT(context, GLTexStorage2DEXT,
9833 "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d",
9834 CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels,
9835 GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height);
9836
9837 if (context)
9838 {
9839 TextureType targetPacked = PackParam<TextureType>(target);
9840 SCOPED_SHARE_CONTEXT_LOCK(context);
9841 bool isCallValid =
9842 (context->skipValidation() ||
9843 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9844 context->getMutableErrorSetForValidation(),
9845 angle::EntryPoint::GLTexStorage2DEXT) &&
9846 ValidateTexStorage2DEXT(context, angle::EntryPoint::GLTexStorage2DEXT, targetPacked,
9847 levels, internalformat, width, height)));
9848 if (isCallValid)
9849 {
9850 context->texStorage2D(targetPacked, levels, internalformat, width, height);
9851 }
9852 ANGLE_CAPTURE_GL(TexStorage2DEXT, isCallValid, context, targetPacked, levels,
9853 internalformat, width, height);
9854 }
9855 else
9856 {
9857 GenerateContextLostErrorOnCurrentGlobalContext();
9858 }
9859 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9860 }
9861
GL_TexStorage3DEXT(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)9862 void GL_APIENTRY GL_TexStorage3DEXT(GLenum target,
9863 GLsizei levels,
9864 GLenum internalformat,
9865 GLsizei width,
9866 GLsizei height,
9867 GLsizei depth)
9868 {
9869 Context *context = GetValidGlobalContext();
9870 EVENT(context, GLTexStorage3DEXT,
9871 "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d, "
9872 "depth = %d",
9873 CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels,
9874 GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height, depth);
9875
9876 if (context)
9877 {
9878 TextureType targetPacked = PackParam<TextureType>(target);
9879 SCOPED_SHARE_CONTEXT_LOCK(context);
9880 bool isCallValid =
9881 (context->skipValidation() ||
9882 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9883 context->getMutableErrorSetForValidation(),
9884 angle::EntryPoint::GLTexStorage3DEXT) &&
9885 ValidateTexStorage3DEXT(context, angle::EntryPoint::GLTexStorage3DEXT, targetPacked,
9886 levels, internalformat, width, height, depth)));
9887 if (isCallValid)
9888 {
9889 context->texStorage3D(targetPacked, levels, internalformat, width, height, depth);
9890 }
9891 ANGLE_CAPTURE_GL(TexStorage3DEXT, isCallValid, context, targetPacked, levels,
9892 internalformat, width, height, depth);
9893 }
9894 else
9895 {
9896 GenerateContextLostErrorOnCurrentGlobalContext();
9897 }
9898 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9899 }
9900
9901 // GL_EXT_texture_type_2_10_10_10_REV
9902
9903 // GL_EXT_unpack_subimage
9904
9905 // GL_IMG_texture_compression_pvrtc
9906
9907 // GL_IMG_texture_compression_pvrtc2
9908
9909 // GL_KHR_blend_equation_advanced
GL_BlendBarrierKHR()9910 void GL_APIENTRY GL_BlendBarrierKHR()
9911 {
9912 Context *context = GetValidGlobalContext();
9913 EVENT(context, GLBlendBarrierKHR, "context = %d", CID(context));
9914
9915 if (context)
9916 {
9917 SCOPED_SHARE_CONTEXT_LOCK(context);
9918 bool isCallValid =
9919 (context->skipValidation() ||
9920 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
9921 context->getMutableErrorSetForValidation(),
9922 angle::EntryPoint::GLBlendBarrierKHR) &&
9923 ValidateBlendBarrierKHR(context, angle::EntryPoint::GLBlendBarrierKHR)));
9924 if (isCallValid)
9925 {
9926 context->blendBarrier();
9927 }
9928 ANGLE_CAPTURE_GL(BlendBarrierKHR, isCallValid, context);
9929 }
9930 else
9931 {
9932 GenerateContextLostErrorOnCurrentGlobalContext();
9933 }
9934 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9935 }
9936
9937 // GL_KHR_debug
GL_DebugMessageCallbackKHR(GLDEBUGPROCKHR callback,const void * userParam)9938 void GL_APIENTRY GL_DebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void *userParam)
9939 {
9940 Context *context = GetValidGlobalContext();
9941 EVENT(context, GLDebugMessageCallbackKHR,
9942 "context = %d, callback = 0x%016" PRIxPTR ", userParam = 0x%016" PRIxPTR "", CID(context),
9943 (uintptr_t)callback, (uintptr_t)userParam);
9944
9945 if (context)
9946 {
9947 SCOPED_SHARE_CONTEXT_LOCK(context);
9948 bool isCallValid =
9949 (context->skipValidation() ||
9950 ValidateDebugMessageCallbackKHR(context, angle::EntryPoint::GLDebugMessageCallbackKHR,
9951 callback, userParam));
9952 if (isCallValid)
9953 {
9954 context->debugMessageCallback(callback, userParam);
9955 }
9956 ANGLE_CAPTURE_GL(DebugMessageCallbackKHR, isCallValid, context, callback, userParam);
9957 }
9958 else
9959 {
9960 GenerateContextLostErrorOnCurrentGlobalContext();
9961 }
9962 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
9963 }
9964
GL_DebugMessageControlKHR(GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint * ids,GLboolean enabled)9965 void GL_APIENTRY GL_DebugMessageControlKHR(GLenum source,
9966 GLenum type,
9967 GLenum severity,
9968 GLsizei count,
9969 const GLuint *ids,
9970 GLboolean enabled)
9971 {
9972 Context *context = GetValidGlobalContext();
9973 EVENT(context, GLDebugMessageControlKHR,
9974 "context = %d, source = %s, type = %s, severity = %s, count = %d, ids = 0x%016" PRIxPTR
9975 ", enabled = %s",
9976 CID(context), GLenumToString(GLESEnum::DebugSource, source),
9977 GLenumToString(GLESEnum::DebugType, type),
9978 GLenumToString(GLESEnum::DebugSeverity, severity), count, (uintptr_t)ids,
9979 GLbooleanToString(enabled));
9980
9981 if (context)
9982 {
9983 SCOPED_SHARE_CONTEXT_LOCK(context);
9984 bool isCallValid =
9985 (context->skipValidation() ||
9986 ValidateDebugMessageControlKHR(context, angle::EntryPoint::GLDebugMessageControlKHR,
9987 source, type, severity, count, ids, enabled));
9988 if (isCallValid)
9989 {
9990 context->debugMessageControl(source, type, severity, count, ids, enabled);
9991 }
9992 ANGLE_CAPTURE_GL(DebugMessageControlKHR, isCallValid, context, source, type, severity,
9993 count, ids, enabled);
9994 }
9995 else
9996 {
9997 GenerateContextLostErrorOnCurrentGlobalContext();
9998 }
9999 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10000 }
10001
GL_DebugMessageInsertKHR(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar * buf)10002 void GL_APIENTRY GL_DebugMessageInsertKHR(GLenum source,
10003 GLenum type,
10004 GLuint id,
10005 GLenum severity,
10006 GLsizei length,
10007 const GLchar *buf)
10008 {
10009 Context *context = GetValidGlobalContext();
10010 EVENT(context, GLDebugMessageInsertKHR,
10011 "context = %d, source = %s, type = %s, id = %u, severity = %s, length = %d, buf = "
10012 "0x%016" PRIxPTR "",
10013 CID(context), GLenumToString(GLESEnum::DebugSource, source),
10014 GLenumToString(GLESEnum::DebugType, type), id,
10015 GLenumToString(GLESEnum::DebugSeverity, severity), length, (uintptr_t)buf);
10016
10017 if (context)
10018 {
10019 SCOPED_SHARE_CONTEXT_LOCK(context);
10020 bool isCallValid =
10021 (context->skipValidation() ||
10022 ValidateDebugMessageInsertKHR(context, angle::EntryPoint::GLDebugMessageInsertKHR,
10023 source, type, id, severity, length, buf));
10024 if (isCallValid)
10025 {
10026 context->debugMessageInsert(source, type, id, severity, length, buf);
10027 }
10028 ANGLE_CAPTURE_GL(DebugMessageInsertKHR, isCallValid, context, source, type, id, severity,
10029 length, buf);
10030 }
10031 else
10032 {
10033 GenerateContextLostErrorOnCurrentGlobalContext();
10034 }
10035 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10036 }
10037
GL_GetDebugMessageLogKHR(GLuint count,GLsizei bufSize,GLenum * sources,GLenum * types,GLuint * ids,GLenum * severities,GLsizei * lengths,GLchar * messageLog)10038 GLuint GL_APIENTRY GL_GetDebugMessageLogKHR(GLuint count,
10039 GLsizei bufSize,
10040 GLenum *sources,
10041 GLenum *types,
10042 GLuint *ids,
10043 GLenum *severities,
10044 GLsizei *lengths,
10045 GLchar *messageLog)
10046 {
10047 Context *context = GetValidGlobalContext();
10048 EVENT(context, GLGetDebugMessageLogKHR,
10049 "context = %d, count = %u, bufSize = %d, sources = 0x%016" PRIxPTR
10050 ", types = 0x%016" PRIxPTR ", ids = 0x%016" PRIxPTR ", severities = 0x%016" PRIxPTR
10051 ", lengths = 0x%016" PRIxPTR ", messageLog = 0x%016" PRIxPTR "",
10052 CID(context), count, bufSize, (uintptr_t)sources, (uintptr_t)types, (uintptr_t)ids,
10053 (uintptr_t)severities, (uintptr_t)lengths, (uintptr_t)messageLog);
10054
10055 GLuint returnValue;
10056 if (context)
10057 {
10058 SCOPED_SHARE_CONTEXT_LOCK(context);
10059 bool isCallValid = (context->skipValidation() ||
10060 ValidateGetDebugMessageLogKHR(
10061 context, angle::EntryPoint::GLGetDebugMessageLogKHR, count, bufSize,
10062 sources, types, ids, severities, lengths, messageLog));
10063 if (isCallValid)
10064 {
10065 returnValue = context->getDebugMessageLog(count, bufSize, sources, types, ids,
10066 severities, lengths, messageLog);
10067 }
10068 else
10069 {
10070 returnValue =
10071 GetDefaultReturnValue<angle::EntryPoint::GLGetDebugMessageLogKHR, GLuint>();
10072 }
10073 ANGLE_CAPTURE_GL(GetDebugMessageLogKHR, isCallValid, context, count, bufSize, sources,
10074 types, ids, severities, lengths, messageLog, returnValue);
10075 }
10076 else
10077 {
10078 GenerateContextLostErrorOnCurrentGlobalContext();
10079 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetDebugMessageLogKHR, GLuint>();
10080 }
10081 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10082 return returnValue;
10083 }
10084
GL_GetObjectLabelKHR(GLenum identifier,GLuint name,GLsizei bufSize,GLsizei * length,GLchar * label)10085 void GL_APIENTRY GL_GetObjectLabelKHR(GLenum identifier,
10086 GLuint name,
10087 GLsizei bufSize,
10088 GLsizei *length,
10089 GLchar *label)
10090 {
10091 Context *context = GetValidGlobalContext();
10092 EVENT(context, GLGetObjectLabelKHR,
10093 "context = %d, identifier = %s, name = %u, bufSize = %d, length = 0x%016" PRIxPTR
10094 ", label = 0x%016" PRIxPTR "",
10095 CID(context), GLenumToString(GLESEnum::AllEnums, identifier), name, bufSize,
10096 (uintptr_t)length, (uintptr_t)label);
10097
10098 if (context)
10099 {
10100 SCOPED_SHARE_CONTEXT_LOCK(context);
10101 bool isCallValid =
10102 (context->skipValidation() ||
10103 ValidateGetObjectLabelKHR(context, angle::EntryPoint::GLGetObjectLabelKHR, identifier,
10104 name, bufSize, length, label));
10105 if (isCallValid)
10106 {
10107 context->getObjectLabel(identifier, name, bufSize, length, label);
10108 }
10109 ANGLE_CAPTURE_GL(GetObjectLabelKHR, isCallValid, context, identifier, name, bufSize, length,
10110 label);
10111 }
10112 else
10113 {
10114 GenerateContextLostErrorOnCurrentGlobalContext();
10115 }
10116 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10117 }
10118
GL_GetObjectPtrLabelKHR(const void * ptr,GLsizei bufSize,GLsizei * length,GLchar * label)10119 void GL_APIENTRY GL_GetObjectPtrLabelKHR(const void *ptr,
10120 GLsizei bufSize,
10121 GLsizei *length,
10122 GLchar *label)
10123 {
10124 Context *context = GetValidGlobalContext();
10125 EVENT(context, GLGetObjectPtrLabelKHR,
10126 "context = %d, ptr = 0x%016" PRIxPTR ", bufSize = %d, length = 0x%016" PRIxPTR
10127 ", label = 0x%016" PRIxPTR "",
10128 CID(context), (uintptr_t)ptr, bufSize, (uintptr_t)length, (uintptr_t)label);
10129
10130 if (context)
10131 {
10132 SCOPED_SHARE_CONTEXT_LOCK(context);
10133 bool isCallValid =
10134 (context->skipValidation() ||
10135 ValidateGetObjectPtrLabelKHR(context, angle::EntryPoint::GLGetObjectPtrLabelKHR, ptr,
10136 bufSize, length, label));
10137 if (isCallValid)
10138 {
10139 context->getObjectPtrLabel(ptr, bufSize, length, label);
10140 }
10141 ANGLE_CAPTURE_GL(GetObjectPtrLabelKHR, isCallValid, context, ptr, bufSize, length, label);
10142 }
10143 else
10144 {
10145 GenerateContextLostErrorOnCurrentGlobalContext();
10146 }
10147 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10148 }
10149
GL_GetPointervKHR(GLenum pname,void ** params)10150 void GL_APIENTRY GL_GetPointervKHR(GLenum pname, void **params)
10151 {
10152 Context *context = GetValidGlobalContext();
10153 EVENT(context, GLGetPointervKHR, "context = %d, pname = %s, params = 0x%016" PRIxPTR "",
10154 CID(context), GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params);
10155
10156 if (context)
10157 {
10158 SCOPED_SHARE_CONTEXT_LOCK(context);
10159 bool isCallValid =
10160 (context->skipValidation() ||
10161 ValidateGetPointervKHR(context, angle::EntryPoint::GLGetPointervKHR, pname, params));
10162 if (isCallValid)
10163 {
10164 context->getPointerv(pname, params);
10165 }
10166 ANGLE_CAPTURE_GL(GetPointervKHR, isCallValid, context, pname, params);
10167 }
10168 else
10169 {
10170 GenerateContextLostErrorOnCurrentGlobalContext();
10171 }
10172 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10173 }
10174
GL_ObjectLabelKHR(GLenum identifier,GLuint name,GLsizei length,const GLchar * label)10175 void GL_APIENTRY GL_ObjectLabelKHR(GLenum identifier,
10176 GLuint name,
10177 GLsizei length,
10178 const GLchar *label)
10179 {
10180 Context *context = GetValidGlobalContext();
10181 EVENT(context, GLObjectLabelKHR,
10182 "context = %d, identifier = %s, name = %u, length = %d, label = 0x%016" PRIxPTR "",
10183 CID(context), GLenumToString(GLESEnum::ObjectIdentifier, identifier), name, length,
10184 (uintptr_t)label);
10185
10186 if (context)
10187 {
10188 SCOPED_SHARE_CONTEXT_LOCK(context);
10189 bool isCallValid = (context->skipValidation() ||
10190 ValidateObjectLabelKHR(context, angle::EntryPoint::GLObjectLabelKHR,
10191 identifier, name, length, label));
10192 if (isCallValid)
10193 {
10194 context->objectLabel(identifier, name, length, label);
10195 }
10196 ANGLE_CAPTURE_GL(ObjectLabelKHR, isCallValid, context, identifier, name, length, label);
10197 }
10198 else
10199 {
10200 GenerateContextLostErrorOnCurrentGlobalContext();
10201 }
10202 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10203 }
10204
GL_ObjectPtrLabelKHR(const void * ptr,GLsizei length,const GLchar * label)10205 void GL_APIENTRY GL_ObjectPtrLabelKHR(const void *ptr, GLsizei length, const GLchar *label)
10206 {
10207 Context *context = GetValidGlobalContext();
10208 EVENT(context, GLObjectPtrLabelKHR,
10209 "context = %d, ptr = 0x%016" PRIxPTR ", length = %d, label = 0x%016" PRIxPTR "",
10210 CID(context), (uintptr_t)ptr, length, (uintptr_t)label);
10211
10212 if (context)
10213 {
10214 SCOPED_SHARE_CONTEXT_LOCK(context);
10215 bool isCallValid =
10216 (context->skipValidation() ||
10217 ValidateObjectPtrLabelKHR(context, angle::EntryPoint::GLObjectPtrLabelKHR, ptr, length,
10218 label));
10219 if (isCallValid)
10220 {
10221 context->objectPtrLabel(ptr, length, label);
10222 }
10223 ANGLE_CAPTURE_GL(ObjectPtrLabelKHR, isCallValid, context, ptr, length, label);
10224 }
10225 else
10226 {
10227 GenerateContextLostErrorOnCurrentGlobalContext();
10228 }
10229 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10230 }
10231
GL_PopDebugGroupKHR()10232 void GL_APIENTRY GL_PopDebugGroupKHR()
10233 {
10234 Context *context = GetValidGlobalContext();
10235 EVENT(context, GLPopDebugGroupKHR, "context = %d", CID(context));
10236
10237 if (context)
10238 {
10239 SCOPED_SHARE_CONTEXT_LOCK(context);
10240 bool isCallValid =
10241 (context->skipValidation() ||
10242 ValidatePopDebugGroupKHR(context, angle::EntryPoint::GLPopDebugGroupKHR));
10243 if (isCallValid)
10244 {
10245 context->popDebugGroup();
10246 }
10247 ANGLE_CAPTURE_GL(PopDebugGroupKHR, isCallValid, context);
10248 }
10249 else
10250 {
10251 GenerateContextLostErrorOnCurrentGlobalContext();
10252 }
10253 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10254 }
10255
GL_PushDebugGroupKHR(GLenum source,GLuint id,GLsizei length,const GLchar * message)10256 void GL_APIENTRY GL_PushDebugGroupKHR(GLenum source,
10257 GLuint id,
10258 GLsizei length,
10259 const GLchar *message)
10260 {
10261 Context *context = GetValidGlobalContext();
10262 EVENT(context, GLPushDebugGroupKHR,
10263 "context = %d, source = %s, id = %u, length = %d, message = 0x%016" PRIxPTR "",
10264 CID(context), GLenumToString(GLESEnum::DebugSource, source), id, length,
10265 (uintptr_t)message);
10266
10267 if (context)
10268 {
10269 SCOPED_SHARE_CONTEXT_LOCK(context);
10270 bool isCallValid =
10271 (context->skipValidation() ||
10272 ValidatePushDebugGroupKHR(context, angle::EntryPoint::GLPushDebugGroupKHR, source, id,
10273 length, message));
10274 if (isCallValid)
10275 {
10276 context->pushDebugGroup(source, id, length, message);
10277 }
10278 ANGLE_CAPTURE_GL(PushDebugGroupKHR, isCallValid, context, source, id, length, message);
10279 }
10280 else
10281 {
10282 GenerateContextLostErrorOnCurrentGlobalContext();
10283 }
10284 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10285 }
10286
10287 // GL_KHR_no_error
10288
10289 // GL_KHR_parallel_shader_compile
GL_MaxShaderCompilerThreadsKHR(GLuint count)10290 void GL_APIENTRY GL_MaxShaderCompilerThreadsKHR(GLuint count)
10291 {
10292 Context *context = GetValidGlobalContext();
10293 EVENT(context, GLMaxShaderCompilerThreadsKHR, "context = %d, count = %u", CID(context), count);
10294
10295 if (context)
10296 {
10297 SCOPED_SHARE_CONTEXT_LOCK(context);
10298 bool isCallValid =
10299 (context->skipValidation() ||
10300 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
10301 context->getMutableErrorSetForValidation(),
10302 angle::EntryPoint::GLMaxShaderCompilerThreadsKHR) &&
10303 ValidateMaxShaderCompilerThreadsKHR(
10304 context, angle::EntryPoint::GLMaxShaderCompilerThreadsKHR, count)));
10305 if (isCallValid)
10306 {
10307 context->maxShaderCompilerThreads(count);
10308 }
10309 ANGLE_CAPTURE_GL(MaxShaderCompilerThreadsKHR, isCallValid, context, count);
10310 }
10311 else
10312 {
10313 GenerateContextLostErrorOnCurrentGlobalContext();
10314 }
10315 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10316 }
10317
10318 // GL_KHR_robust_buffer_access_behavior
10319
10320 // GL_KHR_robustness
GL_GetGraphicsResetStatusKHR()10321 GLenum GL_APIENTRY GL_GetGraphicsResetStatusKHR()
10322 {
10323 Context *context = GetGlobalContext();
10324 EVENT(context, GLGetGraphicsResetStatusKHR, "context = %d", CID(context));
10325
10326 GLenum returnValue;
10327 if (context)
10328 {
10329 SCOPED_SHARE_CONTEXT_LOCK(context);
10330 bool isCallValid = (context->skipValidation() ||
10331 ValidateGetGraphicsResetStatusKHR(
10332 context, angle::EntryPoint::GLGetGraphicsResetStatusKHR));
10333 if (isCallValid)
10334 {
10335 returnValue = context->getGraphicsResetStatus();
10336 }
10337 else
10338 {
10339 returnValue =
10340 GetDefaultReturnValue<angle::EntryPoint::GLGetGraphicsResetStatusKHR, GLenum>();
10341 }
10342 ANGLE_CAPTURE_GL(GetGraphicsResetStatusKHR, isCallValid, context, returnValue);
10343 }
10344 else
10345 {
10346
10347 returnValue =
10348 GetDefaultReturnValue<angle::EntryPoint::GLGetGraphicsResetStatusKHR, GLenum>();
10349 }
10350 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10351 return returnValue;
10352 }
10353
GL_GetnUniformfvKHR(GLuint program,GLint location,GLsizei bufSize,GLfloat * params)10354 void GL_APIENTRY GL_GetnUniformfvKHR(GLuint program,
10355 GLint location,
10356 GLsizei bufSize,
10357 GLfloat *params)
10358 {
10359 Context *context = GetValidGlobalContext();
10360 EVENT(context, GLGetnUniformfvKHR,
10361 "context = %d, program = %u, location = %d, bufSize = %d, params = 0x%016" PRIxPTR "",
10362 CID(context), program, location, bufSize, (uintptr_t)params);
10363
10364 if (context)
10365 {
10366 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
10367 UniformLocation locationPacked = PackParam<UniformLocation>(location);
10368 SCOPED_SHARE_CONTEXT_LOCK(context);
10369 bool isCallValid =
10370 (context->skipValidation() ||
10371 ValidateGetnUniformfvKHR(context, angle::EntryPoint::GLGetnUniformfvKHR, programPacked,
10372 locationPacked, bufSize, params));
10373 if (isCallValid)
10374 {
10375 context->getnUniformfv(programPacked, locationPacked, bufSize, params);
10376 }
10377 ANGLE_CAPTURE_GL(GetnUniformfvKHR, isCallValid, context, programPacked, locationPacked,
10378 bufSize, params);
10379 }
10380 else
10381 {
10382 GenerateContextLostErrorOnCurrentGlobalContext();
10383 }
10384 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10385 }
10386
GL_GetnUniformivKHR(GLuint program,GLint location,GLsizei bufSize,GLint * params)10387 void GL_APIENTRY GL_GetnUniformivKHR(GLuint program, GLint location, GLsizei bufSize, GLint *params)
10388 {
10389 Context *context = GetValidGlobalContext();
10390 EVENT(context, GLGetnUniformivKHR,
10391 "context = %d, program = %u, location = %d, bufSize = %d, params = 0x%016" PRIxPTR "",
10392 CID(context), program, location, bufSize, (uintptr_t)params);
10393
10394 if (context)
10395 {
10396 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
10397 UniformLocation locationPacked = PackParam<UniformLocation>(location);
10398 SCOPED_SHARE_CONTEXT_LOCK(context);
10399 bool isCallValid =
10400 (context->skipValidation() ||
10401 ValidateGetnUniformivKHR(context, angle::EntryPoint::GLGetnUniformivKHR, programPacked,
10402 locationPacked, bufSize, params));
10403 if (isCallValid)
10404 {
10405 context->getnUniformiv(programPacked, locationPacked, bufSize, params);
10406 }
10407 ANGLE_CAPTURE_GL(GetnUniformivKHR, isCallValid, context, programPacked, locationPacked,
10408 bufSize, params);
10409 }
10410 else
10411 {
10412 GenerateContextLostErrorOnCurrentGlobalContext();
10413 }
10414 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10415 }
10416
GL_GetnUniformuivKHR(GLuint program,GLint location,GLsizei bufSize,GLuint * params)10417 void GL_APIENTRY GL_GetnUniformuivKHR(GLuint program,
10418 GLint location,
10419 GLsizei bufSize,
10420 GLuint *params)
10421 {
10422 Context *context = GetValidGlobalContext();
10423 EVENT(context, GLGetnUniformuivKHR,
10424 "context = %d, program = %u, location = %d, bufSize = %d, params = 0x%016" PRIxPTR "",
10425 CID(context), program, location, bufSize, (uintptr_t)params);
10426
10427 if (context)
10428 {
10429 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
10430 UniformLocation locationPacked = PackParam<UniformLocation>(location);
10431 SCOPED_SHARE_CONTEXT_LOCK(context);
10432 bool isCallValid =
10433 (context->skipValidation() ||
10434 ValidateGetnUniformuivKHR(context, angle::EntryPoint::GLGetnUniformuivKHR,
10435 programPacked, locationPacked, bufSize, params));
10436 if (isCallValid)
10437 {
10438 context->getnUniformuiv(programPacked, locationPacked, bufSize, params);
10439 }
10440 ANGLE_CAPTURE_GL(GetnUniformuivKHR, isCallValid, context, programPacked, locationPacked,
10441 bufSize, params);
10442 }
10443 else
10444 {
10445 GenerateContextLostErrorOnCurrentGlobalContext();
10446 }
10447 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10448 }
10449
GL_ReadnPixelsKHR(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)10450 void GL_APIENTRY GL_ReadnPixelsKHR(GLint x,
10451 GLint y,
10452 GLsizei width,
10453 GLsizei height,
10454 GLenum format,
10455 GLenum type,
10456 GLsizei bufSize,
10457 void *data)
10458 {
10459 Context *context = GetValidGlobalContext();
10460 EVENT(context, GLReadnPixelsKHR,
10461 "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize "
10462 "= %d, data = 0x%016" PRIxPTR "",
10463 CID(context), x, y, width, height, GLenumToString(GLESEnum::PixelFormat, format),
10464 GLenumToString(GLESEnum::PixelType, type), bufSize, (uintptr_t)data);
10465
10466 if (context)
10467 {
10468 SCOPED_SHARE_CONTEXT_LOCK(context);
10469 bool isCallValid =
10470 (context->skipValidation() ||
10471 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
10472 context->getMutableErrorSetForValidation(),
10473 angle::EntryPoint::GLReadnPixelsKHR) &&
10474 ValidateReadnPixelsKHR(context, angle::EntryPoint::GLReadnPixelsKHR, x, y, width,
10475 height, format, type, bufSize, data)));
10476 if (isCallValid)
10477 {
10478 context->readnPixels(x, y, width, height, format, type, bufSize, data);
10479 }
10480 ANGLE_CAPTURE_GL(ReadnPixelsKHR, isCallValid, context, x, y, width, height, format, type,
10481 bufSize, data);
10482 }
10483 else
10484 {
10485 GenerateContextLostErrorOnCurrentGlobalContext();
10486 }
10487 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10488 }
10489
10490 // GL_KHR_texture_compression_astc_hdr
10491
10492 // GL_KHR_texture_compression_astc_ldr
10493
10494 // GL_KHR_texture_compression_astc_sliced_3d
10495
10496 // GL_MESA_framebuffer_flip_y
GL_FramebufferParameteriMESA(GLenum target,GLenum pname,GLint param)10497 void GL_APIENTRY GL_FramebufferParameteriMESA(GLenum target, GLenum pname, GLint param)
10498 {
10499 Context *context = GetValidGlobalContext();
10500 EVENT(context, GLFramebufferParameteriMESA, "context = %d, target = %s, pname = %s, param = %d",
10501 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
10502 GLenumToString(GLESEnum::FramebufferParameterName, pname), param);
10503
10504 if (context)
10505 {
10506 SCOPED_SHARE_CONTEXT_LOCK(context);
10507 bool isCallValid =
10508 (context->skipValidation() ||
10509 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
10510 context->getMutableErrorSetForValidation(),
10511 angle::EntryPoint::GLFramebufferParameteriMESA) &&
10512 ValidateFramebufferParameteriMESA(
10513 context, angle::EntryPoint::GLFramebufferParameteriMESA, target, pname, param)));
10514 if (isCallValid)
10515 {
10516 context->framebufferParameteriMESA(target, pname, param);
10517 }
10518 ANGLE_CAPTURE_GL(FramebufferParameteriMESA, isCallValid, context, target, pname, param);
10519 }
10520 else
10521 {
10522 GenerateContextLostErrorOnCurrentGlobalContext();
10523 }
10524 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10525 }
10526
GL_GetFramebufferParameterivMESA(GLenum target,GLenum pname,GLint * params)10527 void GL_APIENTRY GL_GetFramebufferParameterivMESA(GLenum target, GLenum pname, GLint *params)
10528 {
10529 Context *context = GetValidGlobalContext();
10530 EVENT(context, GLGetFramebufferParameterivMESA,
10531 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
10532 GLenumToString(GLESEnum::FramebufferTarget, target),
10533 GLenumToString(GLESEnum::FramebufferAttachmentParameterName, pname), (uintptr_t)params);
10534
10535 if (context)
10536 {
10537 SCOPED_SHARE_CONTEXT_LOCK(context);
10538 bool isCallValid = (context->skipValidation() ||
10539 ValidateGetFramebufferParameterivMESA(
10540 context, angle::EntryPoint::GLGetFramebufferParameterivMESA, target,
10541 pname, params));
10542 if (isCallValid)
10543 {
10544 context->getFramebufferParameterivMESA(target, pname, params);
10545 }
10546 ANGLE_CAPTURE_GL(GetFramebufferParameterivMESA, isCallValid, context, target, pname,
10547 params);
10548 }
10549 else
10550 {
10551 GenerateContextLostErrorOnCurrentGlobalContext();
10552 }
10553 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10554 }
10555
10556 // GL_NV_fence
GL_DeleteFencesNV(GLsizei n,const GLuint * fences)10557 void GL_APIENTRY GL_DeleteFencesNV(GLsizei n, const GLuint *fences)
10558 {
10559 Context *context = GetValidGlobalContext();
10560 EVENT(context, GLDeleteFencesNV, "context = %d, n = %d, fences = 0x%016" PRIxPTR "",
10561 CID(context), n, (uintptr_t)fences);
10562
10563 if (context)
10564 {
10565 const FenceNVID *fencesPacked = PackParam<const FenceNVID *>(fences);
10566 SCOPED_SHARE_CONTEXT_LOCK(context);
10567 bool isCallValid =
10568 (context->skipValidation() ||
10569 ValidateDeleteFencesNV(context, angle::EntryPoint::GLDeleteFencesNV, n, fencesPacked));
10570 if (isCallValid)
10571 {
10572 context->deleteFencesNV(n, fencesPacked);
10573 }
10574 ANGLE_CAPTURE_GL(DeleteFencesNV, isCallValid, context, n, fencesPacked);
10575 }
10576 else
10577 {
10578 GenerateContextLostErrorOnCurrentGlobalContext();
10579 }
10580 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10581 }
10582
GL_FinishFenceNV(GLuint fence)10583 void GL_APIENTRY GL_FinishFenceNV(GLuint fence)
10584 {
10585 Context *context = GetValidGlobalContext();
10586 EVENT(context, GLFinishFenceNV, "context = %d, fence = %u", CID(context), fence);
10587
10588 if (context)
10589 {
10590 FenceNVID fencePacked = PackParam<FenceNVID>(fence);
10591 SCOPED_SHARE_CONTEXT_LOCK(context);
10592 bool isCallValid =
10593 (context->skipValidation() ||
10594 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
10595 context->getMutableErrorSetForValidation(),
10596 angle::EntryPoint::GLFinishFenceNV) &&
10597 ValidateFinishFenceNV(context, angle::EntryPoint::GLFinishFenceNV, fencePacked)));
10598 if (isCallValid)
10599 {
10600 context->finishFenceNV(fencePacked);
10601 }
10602 ANGLE_CAPTURE_GL(FinishFenceNV, isCallValid, context, fencePacked);
10603 }
10604 else
10605 {
10606 GenerateContextLostErrorOnCurrentGlobalContext();
10607 }
10608 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
10609 }
10610
GL_GenFencesNV(GLsizei n,GLuint * fences)10611 void GL_APIENTRY GL_GenFencesNV(GLsizei n, GLuint *fences)
10612 {
10613 Context *context = GetValidGlobalContext();
10614 EVENT(context, GLGenFencesNV, "context = %d, n = %d, fences = 0x%016" PRIxPTR "", CID(context),
10615 n, (uintptr_t)fences);
10616
10617 if (context)
10618 {
10619 FenceNVID *fencesPacked = PackParam<FenceNVID *>(fences);
10620 SCOPED_SHARE_CONTEXT_LOCK(context);
10621 bool isCallValid =
10622 (context->skipValidation() ||
10623 ValidateGenFencesNV(context, angle::EntryPoint::GLGenFencesNV, n, fencesPacked));
10624 if (isCallValid)
10625 {
10626 context->genFencesNV(n, fencesPacked);
10627 }
10628 ANGLE_CAPTURE_GL(GenFencesNV, isCallValid, context, n, fencesPacked);
10629 }
10630 else
10631 {
10632 GenerateContextLostErrorOnCurrentGlobalContext();
10633 }
10634 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10635 }
10636
GL_GetFenceivNV(GLuint fence,GLenum pname,GLint * params)10637 void GL_APIENTRY GL_GetFenceivNV(GLuint fence, GLenum pname, GLint *params)
10638 {
10639 Context *context = GetValidGlobalContext();
10640 EVENT(context, GLGetFenceivNV,
10641 "context = %d, fence = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), fence,
10642 GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params);
10643
10644 if (context)
10645 {
10646 FenceNVID fencePacked = PackParam<FenceNVID>(fence);
10647 SCOPED_SHARE_CONTEXT_LOCK(context);
10648 bool isCallValid = (context->skipValidation() ||
10649 ValidateGetFenceivNV(context, angle::EntryPoint::GLGetFenceivNV,
10650 fencePacked, pname, params));
10651 if (isCallValid)
10652 {
10653 context->getFenceivNV(fencePacked, pname, params);
10654 }
10655 ANGLE_CAPTURE_GL(GetFenceivNV, isCallValid, context, fencePacked, pname, params);
10656 }
10657 else
10658 {
10659 GenerateContextLostErrorOnCurrentGlobalContext();
10660 }
10661 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10662 }
10663
GL_IsFenceNV(GLuint fence)10664 GLboolean GL_APIENTRY GL_IsFenceNV(GLuint fence)
10665 {
10666 Context *context = GetValidGlobalContext();
10667 EVENT(context, GLIsFenceNV, "context = %d, fence = %u", CID(context), fence);
10668
10669 GLboolean returnValue;
10670 if (context)
10671 {
10672 FenceNVID fencePacked = PackParam<FenceNVID>(fence);
10673 SCOPED_SHARE_CONTEXT_LOCK(context);
10674 bool isCallValid =
10675 (context->skipValidation() ||
10676 ValidateIsFenceNV(context, angle::EntryPoint::GLIsFenceNV, fencePacked));
10677 if (isCallValid)
10678 {
10679 returnValue = context->isFenceNV(fencePacked);
10680 }
10681 else
10682 {
10683 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFenceNV, GLboolean>();
10684 }
10685 ANGLE_CAPTURE_GL(IsFenceNV, isCallValid, context, fencePacked, returnValue);
10686 }
10687 else
10688 {
10689 GenerateContextLostErrorOnCurrentGlobalContext();
10690 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFenceNV, GLboolean>();
10691 }
10692 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10693 return returnValue;
10694 }
10695
GL_SetFenceNV(GLuint fence,GLenum condition)10696 void GL_APIENTRY GL_SetFenceNV(GLuint fence, GLenum condition)
10697 {
10698 Context *context = GetValidGlobalContext();
10699 EVENT(context, GLSetFenceNV, "context = %d, fence = %u, condition = %s", CID(context), fence,
10700 GLenumToString(GLESEnum::AllEnums, condition));
10701
10702 if (context)
10703 {
10704 FenceNVID fencePacked = PackParam<FenceNVID>(fence);
10705 SCOPED_SHARE_CONTEXT_LOCK(context);
10706 bool isCallValid =
10707 (context->skipValidation() ||
10708 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
10709 context->getMutableErrorSetForValidation(),
10710 angle::EntryPoint::GLSetFenceNV) &&
10711 ValidateSetFenceNV(context, angle::EntryPoint::GLSetFenceNV, fencePacked,
10712 condition)));
10713 if (isCallValid)
10714 {
10715 context->setFenceNV(fencePacked, condition);
10716 }
10717 ANGLE_CAPTURE_GL(SetFenceNV, isCallValid, context, fencePacked, condition);
10718 }
10719 else
10720 {
10721 GenerateContextLostErrorOnCurrentGlobalContext();
10722 }
10723 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10724 }
10725
GL_TestFenceNV(GLuint fence)10726 GLboolean GL_APIENTRY GL_TestFenceNV(GLuint fence)
10727 {
10728 Context *context = GetValidGlobalContext();
10729 EVENT(context, GLTestFenceNV, "context = %d, fence = %u", CID(context), fence);
10730
10731 GLboolean returnValue;
10732 if (context)
10733 {
10734 FenceNVID fencePacked = PackParam<FenceNVID>(fence);
10735 SCOPED_SHARE_CONTEXT_LOCK(context);
10736 bool isCallValid =
10737 (context->skipValidation() ||
10738 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
10739 context->getMutableErrorSetForValidation(),
10740 angle::EntryPoint::GLTestFenceNV) &&
10741 ValidateTestFenceNV(context, angle::EntryPoint::GLTestFenceNV, fencePacked)));
10742 if (isCallValid)
10743 {
10744 returnValue = context->testFenceNV(fencePacked);
10745 }
10746 else
10747 {
10748 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLTestFenceNV, GLboolean>();
10749 }
10750 ANGLE_CAPTURE_GL(TestFenceNV, isCallValid, context, fencePacked, returnValue);
10751 }
10752 else
10753 {
10754 GenerateContextLostErrorOnCurrentGlobalContext();
10755 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLTestFenceNV, GLboolean>();
10756 }
10757 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10758 return returnValue;
10759 }
10760
10761 // 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)10762 void GL_APIENTRY GL_BlitFramebufferNV(GLint srcX0,
10763 GLint srcY0,
10764 GLint srcX1,
10765 GLint srcY1,
10766 GLint dstX0,
10767 GLint dstY0,
10768 GLint dstX1,
10769 GLint dstY1,
10770 GLbitfield mask,
10771 GLenum filter)
10772 {
10773 Context *context = GetValidGlobalContext();
10774 EVENT(context, GLBlitFramebufferNV,
10775 "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, "
10776 "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s",
10777 CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
10778 GLbitfieldToString(GLESEnum::ClearBufferMask, mask).c_str(),
10779 GLenumToString(GLESEnum::BlitFramebufferFilter, filter));
10780
10781 if (context)
10782 {
10783 SCOPED_SHARE_CONTEXT_LOCK(context);
10784 bool isCallValid =
10785 (context->skipValidation() ||
10786 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
10787 context->getMutableErrorSetForValidation(),
10788 angle::EntryPoint::GLBlitFramebufferNV) &&
10789 ValidateBlitFramebufferNV(context, angle::EntryPoint::GLBlitFramebufferNV, srcX0,
10790 srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
10791 filter)));
10792 if (isCallValid)
10793 {
10794 context->blitFramebufferNV(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
10795 filter);
10796 }
10797 ANGLE_CAPTURE_GL(BlitFramebufferNV, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0,
10798 dstY0, dstX1, dstY1, mask, filter);
10799 }
10800 else
10801 {
10802 GenerateContextLostErrorOnCurrentGlobalContext();
10803 }
10804 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10805 }
10806
10807 // GL_NV_pixel_buffer_object
10808
10809 // GL_NV_polygon_mode
GL_PolygonModeNV(GLenum face,GLenum mode)10810 void GL_APIENTRY GL_PolygonModeNV(GLenum face, GLenum mode)
10811 {
10812 Context *context = GetValidGlobalContext();
10813 EVENT(context, GLPolygonModeNV, "context = %d, face = %s, mode = %s", CID(context),
10814 GLenumToString(GLESEnum::TriangleFace, face),
10815 GLenumToString(GLESEnum::PolygonMode, mode));
10816
10817 if (context)
10818 {
10819 PolygonMode modePacked = PackParam<PolygonMode>(mode);
10820 bool isCallValid =
10821 (context->skipValidation() ||
10822 ValidatePolygonModeNV(context->getPrivateState(),
10823 context->getMutableErrorSetForValidation(),
10824 angle::EntryPoint::GLPolygonModeNV, face, modePacked));
10825 if (isCallValid)
10826 {
10827 ContextPrivatePolygonModeNV(context->getMutablePrivateState(),
10828 context->getMutablePrivateStateCache(), face, modePacked);
10829 }
10830 ANGLE_CAPTURE_GL(PolygonModeNV, isCallValid, context, face, modePacked);
10831 }
10832 else
10833 {
10834 GenerateContextLostErrorOnCurrentGlobalContext();
10835 }
10836 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10837 }
10838
10839 // GL_NV_read_depth
10840
10841 // GL_NV_read_depth_stencil
10842
10843 // GL_NV_read_stencil
10844
10845 // GL_NV_robustness_video_memory_purge
10846
10847 // GL_NV_shader_noperspective_interpolation
10848
10849 // GL_OES_EGL_image
GL_EGLImageTargetRenderbufferStorageOES(GLenum target,GLeglImageOES image)10850 void GL_APIENTRY GL_EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
10851 {
10852 Context *context = GetValidGlobalContext();
10853 EVENT(context, GLEGLImageTargetRenderbufferStorageOES,
10854 "context = %d, target = %s, image = 0x%016" PRIxPTR "", CID(context),
10855 GLenumToString(GLESEnum::AllEnums, target), (uintptr_t)image);
10856
10857 if (context)
10858 {
10859 egl::ImageID imagePacked = PackParam<egl::ImageID>(image);
10860 SCOPED_EGL_IMAGE_SHARE_CONTEXT_LOCK(context, imagePacked);
10861 bool isCallValid =
10862 (context->skipValidation() ||
10863 (ValidatePixelLocalStorageInactive(
10864 context->getPrivateState(), context->getMutableErrorSetForValidation(),
10865 angle::EntryPoint::GLEGLImageTargetRenderbufferStorageOES) &&
10866 ValidateEGLImageTargetRenderbufferStorageOES(
10867 context, angle::EntryPoint::GLEGLImageTargetRenderbufferStorageOES, target,
10868 imagePacked)));
10869 if (isCallValid)
10870 {
10871 context->eGLImageTargetRenderbufferStorage(target, imagePacked);
10872 }
10873 ANGLE_CAPTURE_GL(EGLImageTargetRenderbufferStorageOES, isCallValid, context, target,
10874 imagePacked);
10875 }
10876 else
10877 {
10878 GenerateContextLostErrorOnCurrentGlobalContext();
10879 }
10880 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10881 }
10882
GL_EGLImageTargetTexture2DOES(GLenum target,GLeglImageOES image)10883 void GL_APIENTRY GL_EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
10884 {
10885 Context *context = GetValidGlobalContext();
10886 EVENT(context, GLEGLImageTargetTexture2DOES,
10887 "context = %d, target = %s, image = 0x%016" PRIxPTR "", CID(context),
10888 GLenumToString(GLESEnum::AllEnums, target), (uintptr_t)image);
10889
10890 if (context)
10891 {
10892 TextureType targetPacked = PackParam<TextureType>(target);
10893 egl::ImageID imagePacked = PackParam<egl::ImageID>(image);
10894 SCOPED_EGL_IMAGE_SHARE_CONTEXT_LOCK(context, imagePacked);
10895 bool isCallValid =
10896 (context->skipValidation() ||
10897 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
10898 context->getMutableErrorSetForValidation(),
10899 angle::EntryPoint::GLEGLImageTargetTexture2DOES) &&
10900 ValidateEGLImageTargetTexture2DOES(context,
10901 angle::EntryPoint::GLEGLImageTargetTexture2DOES,
10902 targetPacked, imagePacked)));
10903 if (isCallValid)
10904 {
10905 context->eGLImageTargetTexture2D(targetPacked, imagePacked);
10906 }
10907 ANGLE_CAPTURE_GL(EGLImageTargetTexture2DOES, isCallValid, context, targetPacked,
10908 imagePacked);
10909 }
10910 else
10911 {
10912 GenerateContextLostErrorOnCurrentGlobalContext();
10913 }
10914 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10915 }
10916
10917 // GL_OES_EGL_image_external
10918
10919 // GL_OES_EGL_image_external_essl3
10920
10921 // GL_OES_compressed_ETC1_RGB8_texture
10922
10923 // GL_OES_compressed_paletted_texture
10924
10925 // 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)10926 void GL_APIENTRY GL_CopyImageSubDataOES(GLuint srcName,
10927 GLenum srcTarget,
10928 GLint srcLevel,
10929 GLint srcX,
10930 GLint srcY,
10931 GLint srcZ,
10932 GLuint dstName,
10933 GLenum dstTarget,
10934 GLint dstLevel,
10935 GLint dstX,
10936 GLint dstY,
10937 GLint dstZ,
10938 GLsizei srcWidth,
10939 GLsizei srcHeight,
10940 GLsizei srcDepth)
10941 {
10942 Context *context = GetValidGlobalContext();
10943 EVENT(context, GLCopyImageSubDataOES,
10944 "context = %d, srcName = %u, srcTarget = %s, srcLevel = %d, srcX = %d, srcY = %d, srcZ = "
10945 "%d, dstName = %u, dstTarget = %s, dstLevel = %d, dstX = %d, dstY = %d, dstZ = %d, "
10946 "srcWidth = %d, srcHeight = %d, srcDepth = %d",
10947 CID(context), srcName, GLenumToString(GLESEnum::CopyBufferSubDataTarget, srcTarget),
10948 srcLevel, srcX, srcY, srcZ, dstName,
10949 GLenumToString(GLESEnum::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY, dstZ,
10950 srcWidth, srcHeight, srcDepth);
10951
10952 if (context)
10953 {
10954 SCOPED_SHARE_CONTEXT_LOCK(context);
10955 bool isCallValid =
10956 (context->skipValidation() ||
10957 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
10958 context->getMutableErrorSetForValidation(),
10959 angle::EntryPoint::GLCopyImageSubDataOES) &&
10960 ValidateCopyImageSubDataOES(context, angle::EntryPoint::GLCopyImageSubDataOES,
10961 srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
10962 dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
10963 srcHeight, srcDepth)));
10964 if (isCallValid)
10965 {
10966 context->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
10967 dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
10968 srcDepth);
10969 }
10970 ANGLE_CAPTURE_GL(CopyImageSubDataOES, isCallValid, context, srcName, srcTarget, srcLevel,
10971 srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
10972 srcHeight, srcDepth);
10973 }
10974 else
10975 {
10976 GenerateContextLostErrorOnCurrentGlobalContext();
10977 }
10978 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
10979 }
10980
10981 // GL_OES_depth24
10982
10983 // GL_OES_depth32
10984
10985 // GL_OES_depth_texture
10986
10987 // GL_OES_draw_buffers_indexed
GL_BlendEquationSeparateiOES(GLuint buf,GLenum modeRGB,GLenum modeAlpha)10988 void GL_APIENTRY GL_BlendEquationSeparateiOES(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
10989 {
10990 Context *context = GetValidGlobalContext();
10991 EVENT(context, GLBlendEquationSeparateiOES,
10992 "context = %d, buf = %u, modeRGB = %s, modeAlpha = %s", CID(context), buf,
10993 GLenumToString(GLESEnum::BlendEquationModeEXT, modeRGB),
10994 GLenumToString(GLESEnum::BlendEquationModeEXT, modeAlpha));
10995
10996 if (context)
10997 {
10998 bool isCallValid =
10999 (context->skipValidation() ||
11000 ValidateBlendEquationSeparateiOES(
11001 context->getPrivateState(), context->getMutableErrorSetForValidation(),
11002 angle::EntryPoint::GLBlendEquationSeparateiOES, buf, modeRGB, modeAlpha));
11003 if (isCallValid)
11004 {
11005 ContextPrivateBlendEquationSeparatei(context->getMutablePrivateState(),
11006 context->getMutablePrivateStateCache(), buf,
11007 modeRGB, modeAlpha);
11008 }
11009 ANGLE_CAPTURE_GL(BlendEquationSeparateiOES, isCallValid, context, buf, modeRGB, modeAlpha);
11010 }
11011 else
11012 {
11013 GenerateContextLostErrorOnCurrentGlobalContext();
11014 }
11015 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11016 }
11017
GL_BlendEquationiOES(GLuint buf,GLenum mode)11018 void GL_APIENTRY GL_BlendEquationiOES(GLuint buf, GLenum mode)
11019 {
11020 Context *context = GetValidGlobalContext();
11021 EVENT(context, GLBlendEquationiOES, "context = %d, buf = %u, mode = %s", CID(context), buf,
11022 GLenumToString(GLESEnum::BlendEquationModeEXT, mode));
11023
11024 if (context)
11025 {
11026 bool isCallValid =
11027 (context->skipValidation() ||
11028 ValidateBlendEquationiOES(context->getPrivateState(),
11029 context->getMutableErrorSetForValidation(),
11030 angle::EntryPoint::GLBlendEquationiOES, buf, mode));
11031 if (isCallValid)
11032 {
11033 ContextPrivateBlendEquationi(context->getMutablePrivateState(),
11034 context->getMutablePrivateStateCache(), buf, mode);
11035 }
11036 ANGLE_CAPTURE_GL(BlendEquationiOES, isCallValid, context, buf, mode);
11037 }
11038 else
11039 {
11040 GenerateContextLostErrorOnCurrentGlobalContext();
11041 }
11042 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11043 }
11044
11045 void GL_APIENTRY
GL_BlendFuncSeparateiOES(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)11046 GL_BlendFuncSeparateiOES(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
11047 {
11048 Context *context = GetValidGlobalContext();
11049 EVENT(context, GLBlendFuncSeparateiOES,
11050 "context = %d, buf = %u, srcRGB = %s, dstRGB = %s, srcAlpha = %s, dstAlpha = %s",
11051 CID(context), buf, GLenumToString(GLESEnum::BlendingFactor, srcRGB),
11052 GLenumToString(GLESEnum::BlendingFactor, dstRGB),
11053 GLenumToString(GLESEnum::BlendingFactor, srcAlpha),
11054 GLenumToString(GLESEnum::BlendingFactor, dstAlpha));
11055
11056 if (context)
11057 {
11058 bool isCallValid =
11059 (context->skipValidation() ||
11060 ValidateBlendFuncSeparateiOES(context->getPrivateState(),
11061 context->getMutableErrorSetForValidation(),
11062 angle::EntryPoint::GLBlendFuncSeparateiOES, buf, srcRGB,
11063 dstRGB, srcAlpha, dstAlpha));
11064 if (isCallValid)
11065 {
11066 ContextPrivateBlendFuncSeparatei(context->getMutablePrivateState(),
11067 context->getMutablePrivateStateCache(), buf, srcRGB,
11068 dstRGB, srcAlpha, dstAlpha);
11069 }
11070 ANGLE_CAPTURE_GL(BlendFuncSeparateiOES, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
11071 dstAlpha);
11072 }
11073 else
11074 {
11075 GenerateContextLostErrorOnCurrentGlobalContext();
11076 }
11077 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11078 }
11079
GL_BlendFunciOES(GLuint buf,GLenum src,GLenum dst)11080 void GL_APIENTRY GL_BlendFunciOES(GLuint buf, GLenum src, GLenum dst)
11081 {
11082 Context *context = GetValidGlobalContext();
11083 EVENT(context, GLBlendFunciOES, "context = %d, buf = %u, src = %s, dst = %s", CID(context), buf,
11084 GLenumToString(GLESEnum::BlendingFactor, src),
11085 GLenumToString(GLESEnum::BlendingFactor, dst));
11086
11087 if (context)
11088 {
11089 bool isCallValid =
11090 (context->skipValidation() ||
11091 ValidateBlendFunciOES(context->getPrivateState(),
11092 context->getMutableErrorSetForValidation(),
11093 angle::EntryPoint::GLBlendFunciOES, buf, src, dst));
11094 if (isCallValid)
11095 {
11096 ContextPrivateBlendFunci(context->getMutablePrivateState(),
11097 context->getMutablePrivateStateCache(), buf, src, dst);
11098 }
11099 ANGLE_CAPTURE_GL(BlendFunciOES, isCallValid, context, buf, src, dst);
11100 }
11101 else
11102 {
11103 GenerateContextLostErrorOnCurrentGlobalContext();
11104 }
11105 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11106 }
11107
GL_ColorMaskiOES(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)11108 void GL_APIENTRY GL_ColorMaskiOES(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
11109 {
11110 Context *context = GetValidGlobalContext();
11111 EVENT(context, GLColorMaskiOES, "context = %d, index = %u, r = %s, g = %s, b = %s, a = %s",
11112 CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
11113 GLbooleanToString(a));
11114
11115 if (context)
11116 {
11117 bool isCallValid =
11118 (context->skipValidation() ||
11119 ValidateColorMaskiOES(context->getPrivateState(),
11120 context->getMutableErrorSetForValidation(),
11121 angle::EntryPoint::GLColorMaskiOES, index, r, g, b, a));
11122 if (isCallValid)
11123 {
11124 ContextPrivateColorMaski(context->getMutablePrivateState(),
11125 context->getMutablePrivateStateCache(), index, r, g, b, a);
11126 }
11127 ANGLE_CAPTURE_GL(ColorMaskiOES, isCallValid, context, index, r, g, b, a);
11128 }
11129 else
11130 {
11131 GenerateContextLostErrorOnCurrentGlobalContext();
11132 }
11133 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11134 }
11135
GL_DisableiOES(GLenum target,GLuint index)11136 void GL_APIENTRY GL_DisableiOES(GLenum target, GLuint index)
11137 {
11138 Context *context = GetValidGlobalContext();
11139 EVENT(context, GLDisableiOES, "context = %d, target = %s, index = %u", CID(context),
11140 GLenumToString(GLESEnum::EnableCap, target), index);
11141
11142 if (context)
11143 {
11144 bool isCallValid = (context->skipValidation() ||
11145 ValidateDisableiOES(context->getPrivateState(),
11146 context->getMutableErrorSetForValidation(),
11147 angle::EntryPoint::GLDisableiOES, target, index));
11148 if (isCallValid)
11149 {
11150 ContextPrivateDisablei(context->getMutablePrivateState(),
11151 context->getMutablePrivateStateCache(), target, index);
11152 }
11153 ANGLE_CAPTURE_GL(DisableiOES, isCallValid, context, target, index);
11154 }
11155 else
11156 {
11157 GenerateContextLostErrorOnCurrentGlobalContext();
11158 }
11159 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11160 }
11161
GL_EnableiOES(GLenum target,GLuint index)11162 void GL_APIENTRY GL_EnableiOES(GLenum target, GLuint index)
11163 {
11164 Context *context = GetValidGlobalContext();
11165 EVENT(context, GLEnableiOES, "context = %d, target = %s, index = %u", CID(context),
11166 GLenumToString(GLESEnum::EnableCap, target), index);
11167
11168 if (context)
11169 {
11170 bool isCallValid = (context->skipValidation() ||
11171 ValidateEnableiOES(context->getPrivateState(),
11172 context->getMutableErrorSetForValidation(),
11173 angle::EntryPoint::GLEnableiOES, target, index));
11174 if (isCallValid)
11175 {
11176 ContextPrivateEnablei(context->getMutablePrivateState(),
11177 context->getMutablePrivateStateCache(), target, index);
11178 }
11179 ANGLE_CAPTURE_GL(EnableiOES, isCallValid, context, target, index);
11180 }
11181 else
11182 {
11183 GenerateContextLostErrorOnCurrentGlobalContext();
11184 }
11185 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11186 }
11187
GL_IsEnablediOES(GLenum target,GLuint index)11188 GLboolean GL_APIENTRY GL_IsEnablediOES(GLenum target, GLuint index)
11189 {
11190 Context *context = GetValidGlobalContext();
11191 EVENT(context, GLIsEnablediOES, "context = %d, target = %s, index = %u", CID(context),
11192 GLenumToString(GLESEnum::EnableCap, target), index);
11193
11194 GLboolean returnValue;
11195 if (context)
11196 {
11197 bool isCallValid =
11198 (context->skipValidation() ||
11199 ValidateIsEnablediOES(context->getPrivateState(),
11200 context->getMutableErrorSetForValidation(),
11201 angle::EntryPoint::GLIsEnablediOES, target, index));
11202 if (isCallValid)
11203 {
11204 returnValue =
11205 ContextPrivateIsEnabledi(context->getMutablePrivateState(),
11206 context->getMutablePrivateStateCache(), target, index);
11207 }
11208 else
11209 {
11210 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediOES, GLboolean>();
11211 }
11212 ANGLE_CAPTURE_GL(IsEnablediOES, isCallValid, context, target, index, returnValue);
11213 }
11214 else
11215 {
11216 GenerateContextLostErrorOnCurrentGlobalContext();
11217 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediOES, GLboolean>();
11218 }
11219 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11220 return returnValue;
11221 }
11222
11223 // GL_OES_draw_elements_base_vertex
GL_DrawElementsBaseVertexOES(GLenum mode,GLsizei count,GLenum type,const void * indices,GLint basevertex)11224 void GL_APIENTRY GL_DrawElementsBaseVertexOES(GLenum mode,
11225 GLsizei count,
11226 GLenum type,
11227 const void *indices,
11228 GLint basevertex)
11229 {
11230 Context *context = GetValidGlobalContext();
11231 EVENT(context, GLDrawElementsBaseVertexOES,
11232 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
11233 ", basevertex = %d",
11234 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count,
11235 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, basevertex);
11236
11237 if (context)
11238 {
11239 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
11240 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
11241 SCOPED_SHARE_CONTEXT_LOCK(context);
11242 bool isCallValid = (context->skipValidation() ||
11243 ValidateDrawElementsBaseVertexOES(
11244 context, angle::EntryPoint::GLDrawElementsBaseVertexOES, modePacked,
11245 count, typePacked, indices, basevertex));
11246 if (isCallValid)
11247 {
11248 context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex);
11249 }
11250 ANGLE_CAPTURE_GL(DrawElementsBaseVertexOES, isCallValid, context, modePacked, count,
11251 typePacked, indices, basevertex);
11252 }
11253 else
11254 {
11255 GenerateContextLostErrorOnCurrentGlobalContext();
11256 }
11257 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11258 }
11259
GL_DrawElementsInstancedBaseVertexOES(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount,GLint basevertex)11260 void GL_APIENTRY GL_DrawElementsInstancedBaseVertexOES(GLenum mode,
11261 GLsizei count,
11262 GLenum type,
11263 const void *indices,
11264 GLsizei instancecount,
11265 GLint basevertex)
11266 {
11267 Context *context = GetValidGlobalContext();
11268 EVENT(context, GLDrawElementsInstancedBaseVertexOES,
11269 "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR
11270 ", instancecount = %d, basevertex = %d",
11271 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count,
11272 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instancecount,
11273 basevertex);
11274
11275 if (context)
11276 {
11277 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
11278 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
11279 SCOPED_SHARE_CONTEXT_LOCK(context);
11280 bool isCallValid = (context->skipValidation() ||
11281 ValidateDrawElementsInstancedBaseVertexOES(
11282 context, angle::EntryPoint::GLDrawElementsInstancedBaseVertexOES,
11283 modePacked, count, typePacked, indices, instancecount, basevertex));
11284 if (isCallValid)
11285 {
11286 context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices,
11287 instancecount, basevertex);
11288 }
11289 ANGLE_CAPTURE_GL(DrawElementsInstancedBaseVertexOES, isCallValid, context, modePacked,
11290 count, typePacked, indices, instancecount, basevertex);
11291 }
11292 else
11293 {
11294 GenerateContextLostErrorOnCurrentGlobalContext();
11295 }
11296 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11297 }
11298
GL_DrawRangeElementsBaseVertexOES(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices,GLint basevertex)11299 void GL_APIENTRY GL_DrawRangeElementsBaseVertexOES(GLenum mode,
11300 GLuint start,
11301 GLuint end,
11302 GLsizei count,
11303 GLenum type,
11304 const void *indices,
11305 GLint basevertex)
11306 {
11307 Context *context = GetValidGlobalContext();
11308 EVENT(context, GLDrawRangeElementsBaseVertexOES,
11309 "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = "
11310 "0x%016" PRIxPTR ", basevertex = %d",
11311 CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), start, end, count,
11312 GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, basevertex);
11313
11314 if (context)
11315 {
11316 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
11317 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
11318 SCOPED_SHARE_CONTEXT_LOCK(context);
11319 bool isCallValid = (context->skipValidation() ||
11320 ValidateDrawRangeElementsBaseVertexOES(
11321 context, angle::EntryPoint::GLDrawRangeElementsBaseVertexOES,
11322 modePacked, start, end, count, typePacked, indices, basevertex));
11323 if (isCallValid)
11324 {
11325 context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices,
11326 basevertex);
11327 }
11328 ANGLE_CAPTURE_GL(DrawRangeElementsBaseVertexOES, isCallValid, context, modePacked, start,
11329 end, count, typePacked, indices, basevertex);
11330 }
11331 else
11332 {
11333 GenerateContextLostErrorOnCurrentGlobalContext();
11334 }
11335 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11336 }
11337
11338 // MultiDrawElementsBaseVertexEXT is already defined.
11339
11340 // GL_OES_draw_texture
GL_DrawTexfOES(GLfloat x,GLfloat y,GLfloat z,GLfloat width,GLfloat height)11341 void GL_APIENTRY GL_DrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
11342 {
11343 Context *context = GetValidGlobalContext();
11344 EVENT(context, GLDrawTexfOES, "context = %d, x = %f, y = %f, z = %f, width = %f, height = %f",
11345 CID(context), x, y, z, width, height);
11346
11347 if (context)
11348 {
11349 SCOPED_SHARE_CONTEXT_LOCK(context);
11350 bool isCallValid = (context->skipValidation() ||
11351 ValidateDrawTexfOES(context, angle::EntryPoint::GLDrawTexfOES, x, y, z,
11352 width, height));
11353 if (isCallValid)
11354 {
11355 context->drawTexf(x, y, z, width, height);
11356 }
11357 ANGLE_CAPTURE_GL(DrawTexfOES, isCallValid, context, x, y, z, width, height);
11358 }
11359 else
11360 {
11361 GenerateContextLostErrorOnCurrentGlobalContext();
11362 }
11363 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11364 }
11365
GL_DrawTexfvOES(const GLfloat * coords)11366 void GL_APIENTRY GL_DrawTexfvOES(const GLfloat *coords)
11367 {
11368 Context *context = GetValidGlobalContext();
11369 EVENT(context, GLDrawTexfvOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context),
11370 (uintptr_t)coords);
11371
11372 if (context)
11373 {
11374 SCOPED_SHARE_CONTEXT_LOCK(context);
11375 bool isCallValid =
11376 (context->skipValidation() ||
11377 ValidateDrawTexfvOES(context, angle::EntryPoint::GLDrawTexfvOES, coords));
11378 if (isCallValid)
11379 {
11380 context->drawTexfv(coords);
11381 }
11382 ANGLE_CAPTURE_GL(DrawTexfvOES, isCallValid, context, coords);
11383 }
11384 else
11385 {
11386 GenerateContextLostErrorOnCurrentGlobalContext();
11387 }
11388 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11389 }
11390
GL_DrawTexiOES(GLint x,GLint y,GLint z,GLint width,GLint height)11391 void GL_APIENTRY GL_DrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
11392 {
11393 Context *context = GetValidGlobalContext();
11394 EVENT(context, GLDrawTexiOES, "context = %d, x = %d, y = %d, z = %d, width = %d, height = %d",
11395 CID(context), x, y, z, width, height);
11396
11397 if (context)
11398 {
11399 SCOPED_SHARE_CONTEXT_LOCK(context);
11400 bool isCallValid = (context->skipValidation() ||
11401 ValidateDrawTexiOES(context, angle::EntryPoint::GLDrawTexiOES, x, y, z,
11402 width, height));
11403 if (isCallValid)
11404 {
11405 context->drawTexi(x, y, z, width, height);
11406 }
11407 ANGLE_CAPTURE_GL(DrawTexiOES, isCallValid, context, x, y, z, width, height);
11408 }
11409 else
11410 {
11411 GenerateContextLostErrorOnCurrentGlobalContext();
11412 }
11413 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11414 }
11415
GL_DrawTexivOES(const GLint * coords)11416 void GL_APIENTRY GL_DrawTexivOES(const GLint *coords)
11417 {
11418 Context *context = GetValidGlobalContext();
11419 EVENT(context, GLDrawTexivOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context),
11420 (uintptr_t)coords);
11421
11422 if (context)
11423 {
11424 SCOPED_SHARE_CONTEXT_LOCK(context);
11425 bool isCallValid =
11426 (context->skipValidation() ||
11427 ValidateDrawTexivOES(context, angle::EntryPoint::GLDrawTexivOES, coords));
11428 if (isCallValid)
11429 {
11430 context->drawTexiv(coords);
11431 }
11432 ANGLE_CAPTURE_GL(DrawTexivOES, isCallValid, context, coords);
11433 }
11434 else
11435 {
11436 GenerateContextLostErrorOnCurrentGlobalContext();
11437 }
11438 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11439 }
11440
GL_DrawTexsOES(GLshort x,GLshort y,GLshort z,GLshort width,GLshort height)11441 void GL_APIENTRY GL_DrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
11442 {
11443 Context *context = GetValidGlobalContext();
11444 EVENT(context, GLDrawTexsOES, "context = %d, x = %d, y = %d, z = %d, width = %d, height = %d",
11445 CID(context), x, y, z, width, height);
11446
11447 if (context)
11448 {
11449 SCOPED_SHARE_CONTEXT_LOCK(context);
11450 bool isCallValid = (context->skipValidation() ||
11451 ValidateDrawTexsOES(context, angle::EntryPoint::GLDrawTexsOES, x, y, z,
11452 width, height));
11453 if (isCallValid)
11454 {
11455 context->drawTexs(x, y, z, width, height);
11456 }
11457 ANGLE_CAPTURE_GL(DrawTexsOES, isCallValid, context, x, y, z, width, height);
11458 }
11459 else
11460 {
11461 GenerateContextLostErrorOnCurrentGlobalContext();
11462 }
11463 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11464 }
11465
GL_DrawTexsvOES(const GLshort * coords)11466 void GL_APIENTRY GL_DrawTexsvOES(const GLshort *coords)
11467 {
11468 Context *context = GetValidGlobalContext();
11469 EVENT(context, GLDrawTexsvOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context),
11470 (uintptr_t)coords);
11471
11472 if (context)
11473 {
11474 SCOPED_SHARE_CONTEXT_LOCK(context);
11475 bool isCallValid =
11476 (context->skipValidation() ||
11477 ValidateDrawTexsvOES(context, angle::EntryPoint::GLDrawTexsvOES, coords));
11478 if (isCallValid)
11479 {
11480 context->drawTexsv(coords);
11481 }
11482 ANGLE_CAPTURE_GL(DrawTexsvOES, isCallValid, context, coords);
11483 }
11484 else
11485 {
11486 GenerateContextLostErrorOnCurrentGlobalContext();
11487 }
11488 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11489 }
11490
GL_DrawTexxOES(GLfixed x,GLfixed y,GLfixed z,GLfixed width,GLfixed height)11491 void GL_APIENTRY GL_DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
11492 {
11493 Context *context = GetValidGlobalContext();
11494 EVENT(context, GLDrawTexxOES,
11495 "context = %d, x = 0x%X, y = 0x%X, z = 0x%X, width = 0x%X, height = 0x%X", CID(context),
11496 x, y, z, width, height);
11497
11498 if (context)
11499 {
11500 SCOPED_SHARE_CONTEXT_LOCK(context);
11501 bool isCallValid = (context->skipValidation() ||
11502 ValidateDrawTexxOES(context, angle::EntryPoint::GLDrawTexxOES, x, y, z,
11503 width, height));
11504 if (isCallValid)
11505 {
11506 context->drawTexx(x, y, z, width, height);
11507 }
11508 ANGLE_CAPTURE_GL(DrawTexxOES, isCallValid, context, x, y, z, width, height);
11509 }
11510 else
11511 {
11512 GenerateContextLostErrorOnCurrentGlobalContext();
11513 }
11514 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11515 }
11516
GL_DrawTexxvOES(const GLfixed * coords)11517 void GL_APIENTRY GL_DrawTexxvOES(const GLfixed *coords)
11518 {
11519 Context *context = GetValidGlobalContext();
11520 EVENT(context, GLDrawTexxvOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context),
11521 (uintptr_t)coords);
11522
11523 if (context)
11524 {
11525 SCOPED_SHARE_CONTEXT_LOCK(context);
11526 bool isCallValid =
11527 (context->skipValidation() ||
11528 ValidateDrawTexxvOES(context, angle::EntryPoint::GLDrawTexxvOES, coords));
11529 if (isCallValid)
11530 {
11531 context->drawTexxv(coords);
11532 }
11533 ANGLE_CAPTURE_GL(DrawTexxvOES, isCallValid, context, coords);
11534 }
11535 else
11536 {
11537 GenerateContextLostErrorOnCurrentGlobalContext();
11538 }
11539 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11540 }
11541
11542 // GL_OES_element_index_uint
11543
11544 // GL_OES_fbo_render_mipmap
11545
11546 // GL_OES_framebuffer_object
GL_BindFramebufferOES(GLenum target,GLuint framebuffer)11547 void GL_APIENTRY GL_BindFramebufferOES(GLenum target, GLuint framebuffer)
11548 {
11549 Context *context = GetValidGlobalContext();
11550 EVENT(context, GLBindFramebufferOES, "context = %d, target = %s, framebuffer = %u",
11551 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), framebuffer);
11552
11553 if (context)
11554 {
11555 FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
11556 SCOPED_SHARE_CONTEXT_LOCK(context);
11557 bool isCallValid =
11558 (context->skipValidation() ||
11559 ValidateBindFramebufferOES(context, angle::EntryPoint::GLBindFramebufferOES, target,
11560 framebufferPacked));
11561 if (isCallValid)
11562 {
11563 context->bindFramebuffer(target, framebufferPacked);
11564 }
11565 ANGLE_CAPTURE_GL(BindFramebufferOES, isCallValid, context, target, framebufferPacked);
11566 }
11567 else
11568 {
11569 GenerateContextLostErrorOnCurrentGlobalContext();
11570 }
11571 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11572 }
11573
GL_BindRenderbufferOES(GLenum target,GLuint renderbuffer)11574 void GL_APIENTRY GL_BindRenderbufferOES(GLenum target, GLuint renderbuffer)
11575 {
11576 Context *context = GetValidGlobalContext();
11577 EVENT(context, GLBindRenderbufferOES, "context = %d, target = %s, renderbuffer = %u",
11578 CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target), renderbuffer);
11579
11580 if (context)
11581 {
11582 RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
11583 SCOPED_SHARE_CONTEXT_LOCK(context);
11584 bool isCallValid =
11585 (context->skipValidation() ||
11586 ValidateBindRenderbufferOES(context, angle::EntryPoint::GLBindRenderbufferOES, target,
11587 renderbufferPacked));
11588 if (isCallValid)
11589 {
11590 context->bindRenderbuffer(target, renderbufferPacked);
11591 }
11592 ANGLE_CAPTURE_GL(BindRenderbufferOES, isCallValid, context, target, renderbufferPacked);
11593 }
11594 else
11595 {
11596 GenerateContextLostErrorOnCurrentGlobalContext();
11597 }
11598 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11599 }
11600
GL_CheckFramebufferStatusOES(GLenum target)11601 GLenum GL_APIENTRY GL_CheckFramebufferStatusOES(GLenum target)
11602 {
11603 Context *context = GetValidGlobalContext();
11604 EVENT(context, GLCheckFramebufferStatusOES, "context = %d, target = %s", CID(context),
11605 GLenumToString(GLESEnum::FramebufferTarget, target));
11606
11607 GLenum returnValue;
11608 if (context)
11609 {
11610 SCOPED_SHARE_CONTEXT_LOCK(context);
11611 bool isCallValid = (context->skipValidation() ||
11612 ValidateCheckFramebufferStatusOES(
11613 context, angle::EntryPoint::GLCheckFramebufferStatusOES, target));
11614 if (isCallValid)
11615 {
11616 returnValue = context->checkFramebufferStatus(target);
11617 }
11618 else
11619 {
11620 returnValue =
11621 GetDefaultReturnValue<angle::EntryPoint::GLCheckFramebufferStatusOES, GLenum>();
11622 }
11623 ANGLE_CAPTURE_GL(CheckFramebufferStatusOES, isCallValid, context, target, returnValue);
11624 }
11625 else
11626 {
11627 GenerateContextLostErrorOnCurrentGlobalContext();
11628 returnValue =
11629 GetDefaultReturnValue<angle::EntryPoint::GLCheckFramebufferStatusOES, GLenum>();
11630 }
11631 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11632 return returnValue;
11633 }
11634
GL_DeleteFramebuffersOES(GLsizei n,const GLuint * framebuffers)11635 void GL_APIENTRY GL_DeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers)
11636 {
11637 Context *context = GetValidGlobalContext();
11638 EVENT(context, GLDeleteFramebuffersOES,
11639 "context = %d, n = %d, framebuffers = 0x%016" PRIxPTR "", CID(context), n,
11640 (uintptr_t)framebuffers);
11641
11642 if (context)
11643 {
11644 const FramebufferID *framebuffersPacked = PackParam<const FramebufferID *>(framebuffers);
11645 SCOPED_SHARE_CONTEXT_LOCK(context);
11646 bool isCallValid =
11647 (context->skipValidation() ||
11648 ValidateDeleteFramebuffersOES(context, angle::EntryPoint::GLDeleteFramebuffersOES, n,
11649 framebuffersPacked));
11650 if (isCallValid)
11651 {
11652 context->deleteFramebuffers(n, framebuffersPacked);
11653 }
11654 ANGLE_CAPTURE_GL(DeleteFramebuffersOES, isCallValid, context, n, framebuffersPacked);
11655 }
11656 else
11657 {
11658 GenerateContextLostErrorOnCurrentGlobalContext();
11659 }
11660 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11661 }
11662
GL_DeleteRenderbuffersOES(GLsizei n,const GLuint * renderbuffers)11663 void GL_APIENTRY GL_DeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers)
11664 {
11665 Context *context = GetValidGlobalContext();
11666 EVENT(context, GLDeleteRenderbuffersOES,
11667 "context = %d, n = %d, renderbuffers = 0x%016" PRIxPTR "", CID(context), n,
11668 (uintptr_t)renderbuffers);
11669
11670 if (context)
11671 {
11672 const RenderbufferID *renderbuffersPacked =
11673 PackParam<const RenderbufferID *>(renderbuffers);
11674 SCOPED_SHARE_CONTEXT_LOCK(context);
11675 bool isCallValid =
11676 (context->skipValidation() ||
11677 ValidateDeleteRenderbuffersOES(context, angle::EntryPoint::GLDeleteRenderbuffersOES, n,
11678 renderbuffersPacked));
11679 if (isCallValid)
11680 {
11681 context->deleteRenderbuffers(n, renderbuffersPacked);
11682 }
11683 ANGLE_CAPTURE_GL(DeleteRenderbuffersOES, isCallValid, context, n, renderbuffersPacked);
11684 }
11685 else
11686 {
11687 GenerateContextLostErrorOnCurrentGlobalContext();
11688 }
11689 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11690 }
11691
GL_FramebufferRenderbufferOES(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)11692 void GL_APIENTRY GL_FramebufferRenderbufferOES(GLenum target,
11693 GLenum attachment,
11694 GLenum renderbuffertarget,
11695 GLuint renderbuffer)
11696 {
11697 Context *context = GetValidGlobalContext();
11698 EVENT(context, GLFramebufferRenderbufferOES,
11699 "context = %d, target = %s, attachment = %s, renderbuffertarget = %s, renderbuffer = %u",
11700 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
11701 GLenumToString(GLESEnum::FramebufferAttachment, attachment),
11702 GLenumToString(GLESEnum::RenderbufferTarget, renderbuffertarget), renderbuffer);
11703
11704 if (context)
11705 {
11706 RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
11707 SCOPED_SHARE_CONTEXT_LOCK(context);
11708 bool isCallValid = (context->skipValidation() ||
11709 ValidateFramebufferRenderbufferOES(
11710 context, angle::EntryPoint::GLFramebufferRenderbufferOES, target,
11711 attachment, renderbuffertarget, renderbufferPacked));
11712 if (isCallValid)
11713 {
11714 context->framebufferRenderbuffer(target, attachment, renderbuffertarget,
11715 renderbufferPacked);
11716 }
11717 ANGLE_CAPTURE_GL(FramebufferRenderbufferOES, isCallValid, context, target, attachment,
11718 renderbuffertarget, renderbufferPacked);
11719 }
11720 else
11721 {
11722 GenerateContextLostErrorOnCurrentGlobalContext();
11723 }
11724 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11725 }
11726
GL_FramebufferTexture2DOES(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)11727 void GL_APIENTRY GL_FramebufferTexture2DOES(GLenum target,
11728 GLenum attachment,
11729 GLenum textarget,
11730 GLuint texture,
11731 GLint level)
11732 {
11733 Context *context = GetValidGlobalContext();
11734 EVENT(context, GLFramebufferTexture2DOES,
11735 "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d",
11736 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
11737 GLenumToString(GLESEnum::FramebufferAttachment, attachment),
11738 GLenumToString(GLESEnum::TextureTarget, textarget), texture, level);
11739
11740 if (context)
11741 {
11742 TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
11743 TextureID texturePacked = PackParam<TextureID>(texture);
11744 SCOPED_SHARE_CONTEXT_LOCK(context);
11745 bool isCallValid = (context->skipValidation() ||
11746 ValidateFramebufferTexture2DOES(
11747 context, angle::EntryPoint::GLFramebufferTexture2DOES, target,
11748 attachment, textargetPacked, texturePacked, level));
11749 if (isCallValid)
11750 {
11751 context->framebufferTexture2D(target, attachment, textargetPacked, texturePacked,
11752 level);
11753 }
11754 ANGLE_CAPTURE_GL(FramebufferTexture2DOES, isCallValid, context, target, attachment,
11755 textargetPacked, texturePacked, level);
11756 }
11757 else
11758 {
11759 GenerateContextLostErrorOnCurrentGlobalContext();
11760 }
11761 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11762 }
11763
GL_GenFramebuffersOES(GLsizei n,GLuint * framebuffers)11764 void GL_APIENTRY GL_GenFramebuffersOES(GLsizei n, GLuint *framebuffers)
11765 {
11766 Context *context = GetValidGlobalContext();
11767 EVENT(context, GLGenFramebuffersOES, "context = %d, n = %d, framebuffers = 0x%016" PRIxPTR "",
11768 CID(context), n, (uintptr_t)framebuffers);
11769
11770 if (context)
11771 {
11772 FramebufferID *framebuffersPacked = PackParam<FramebufferID *>(framebuffers);
11773 SCOPED_SHARE_CONTEXT_LOCK(context);
11774 bool isCallValid =
11775 (context->skipValidation() ||
11776 ValidateGenFramebuffersOES(context, angle::EntryPoint::GLGenFramebuffersOES, n,
11777 framebuffersPacked));
11778 if (isCallValid)
11779 {
11780 context->genFramebuffers(n, framebuffersPacked);
11781 }
11782 ANGLE_CAPTURE_GL(GenFramebuffersOES, isCallValid, context, n, framebuffersPacked);
11783 }
11784 else
11785 {
11786 GenerateContextLostErrorOnCurrentGlobalContext();
11787 }
11788 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11789 }
11790
GL_GenRenderbuffersOES(GLsizei n,GLuint * renderbuffers)11791 void GL_APIENTRY GL_GenRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
11792 {
11793 Context *context = GetValidGlobalContext();
11794 EVENT(context, GLGenRenderbuffersOES, "context = %d, n = %d, renderbuffers = 0x%016" PRIxPTR "",
11795 CID(context), n, (uintptr_t)renderbuffers);
11796
11797 if (context)
11798 {
11799 RenderbufferID *renderbuffersPacked = PackParam<RenderbufferID *>(renderbuffers);
11800 SCOPED_SHARE_CONTEXT_LOCK(context);
11801 bool isCallValid =
11802 (context->skipValidation() ||
11803 ValidateGenRenderbuffersOES(context, angle::EntryPoint::GLGenRenderbuffersOES, n,
11804 renderbuffersPacked));
11805 if (isCallValid)
11806 {
11807 context->genRenderbuffers(n, renderbuffersPacked);
11808 }
11809 ANGLE_CAPTURE_GL(GenRenderbuffersOES, isCallValid, context, n, renderbuffersPacked);
11810 }
11811 else
11812 {
11813 GenerateContextLostErrorOnCurrentGlobalContext();
11814 }
11815 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11816 }
11817
GL_GenerateMipmapOES(GLenum target)11818 void GL_APIENTRY GL_GenerateMipmapOES(GLenum target)
11819 {
11820 Context *context = GetValidGlobalContext();
11821 EVENT(context, GLGenerateMipmapOES, "context = %d, target = %s", CID(context),
11822 GLenumToString(GLESEnum::TextureTarget, target));
11823
11824 if (context)
11825 {
11826 TextureType targetPacked = PackParam<TextureType>(target);
11827 SCOPED_SHARE_CONTEXT_LOCK(context);
11828 bool isCallValid = (context->skipValidation() ||
11829 ValidateGenerateMipmapOES(
11830 context, angle::EntryPoint::GLGenerateMipmapOES, targetPacked));
11831 if (isCallValid)
11832 {
11833 context->generateMipmap(targetPacked);
11834 }
11835 ANGLE_CAPTURE_GL(GenerateMipmapOES, isCallValid, context, targetPacked);
11836 }
11837 else
11838 {
11839 GenerateContextLostErrorOnCurrentGlobalContext();
11840 }
11841 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11842 }
11843
GL_GetFramebufferAttachmentParameterivOES(GLenum target,GLenum attachment,GLenum pname,GLint * params)11844 void GL_APIENTRY GL_GetFramebufferAttachmentParameterivOES(GLenum target,
11845 GLenum attachment,
11846 GLenum pname,
11847 GLint *params)
11848 {
11849 Context *context = GetValidGlobalContext();
11850 EVENT(context, GLGetFramebufferAttachmentParameterivOES,
11851 "context = %d, target = %s, attachment = %s, pname = %s, params = 0x%016" PRIxPTR "",
11852 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
11853 GLenumToString(GLESEnum::FramebufferAttachment, attachment),
11854 GLenumToString(GLESEnum::FramebufferAttachmentParameterName, pname), (uintptr_t)params);
11855
11856 if (context)
11857 {
11858 SCOPED_SHARE_CONTEXT_LOCK(context);
11859 bool isCallValid =
11860 (context->skipValidation() ||
11861 ValidateGetFramebufferAttachmentParameterivOES(
11862 context, angle::EntryPoint::GLGetFramebufferAttachmentParameterivOES, target,
11863 attachment, pname, params));
11864 if (isCallValid)
11865 {
11866 context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
11867 }
11868 ANGLE_CAPTURE_GL(GetFramebufferAttachmentParameterivOES, isCallValid, context, target,
11869 attachment, pname, params);
11870 }
11871 else
11872 {
11873 GenerateContextLostErrorOnCurrentGlobalContext();
11874 }
11875 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11876 }
11877
GL_GetRenderbufferParameterivOES(GLenum target,GLenum pname,GLint * params)11878 void GL_APIENTRY GL_GetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params)
11879 {
11880 Context *context = GetValidGlobalContext();
11881 EVENT(context, GLGetRenderbufferParameterivOES,
11882 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
11883 GLenumToString(GLESEnum::RenderbufferTarget, target),
11884 GLenumToString(GLESEnum::RenderbufferParameterName, pname), (uintptr_t)params);
11885
11886 if (context)
11887 {
11888 SCOPED_SHARE_CONTEXT_LOCK(context);
11889 bool isCallValid = (context->skipValidation() ||
11890 ValidateGetRenderbufferParameterivOES(
11891 context, angle::EntryPoint::GLGetRenderbufferParameterivOES, target,
11892 pname, params));
11893 if (isCallValid)
11894 {
11895 context->getRenderbufferParameteriv(target, pname, params);
11896 }
11897 ANGLE_CAPTURE_GL(GetRenderbufferParameterivOES, isCallValid, context, target, pname,
11898 params);
11899 }
11900 else
11901 {
11902 GenerateContextLostErrorOnCurrentGlobalContext();
11903 }
11904 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11905 }
11906
GL_IsFramebufferOES(GLuint framebuffer)11907 GLboolean GL_APIENTRY GL_IsFramebufferOES(GLuint framebuffer)
11908 {
11909 Context *context = GetValidGlobalContext();
11910 EVENT(context, GLIsFramebufferOES, "context = %d, framebuffer = %u", CID(context), framebuffer);
11911
11912 GLboolean returnValue;
11913 if (context)
11914 {
11915 FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
11916 SCOPED_SHARE_CONTEXT_LOCK(context);
11917 bool isCallValid = (context->skipValidation() ||
11918 ValidateIsFramebufferOES(context, angle::EntryPoint::GLIsFramebufferOES,
11919 framebufferPacked));
11920 if (isCallValid)
11921 {
11922 returnValue = context->isFramebuffer(framebufferPacked);
11923 }
11924 else
11925 {
11926 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFramebufferOES, GLboolean>();
11927 }
11928 ANGLE_CAPTURE_GL(IsFramebufferOES, isCallValid, context, framebufferPacked, returnValue);
11929 }
11930 else
11931 {
11932 GenerateContextLostErrorOnCurrentGlobalContext();
11933 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFramebufferOES, GLboolean>();
11934 }
11935 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11936 return returnValue;
11937 }
11938
GL_IsRenderbufferOES(GLuint renderbuffer)11939 GLboolean GL_APIENTRY GL_IsRenderbufferOES(GLuint renderbuffer)
11940 {
11941 Context *context = GetValidGlobalContext();
11942 EVENT(context, GLIsRenderbufferOES, "context = %d, renderbuffer = %u", CID(context),
11943 renderbuffer);
11944
11945 GLboolean returnValue;
11946 if (context)
11947 {
11948 RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
11949 SCOPED_SHARE_CONTEXT_LOCK(context);
11950 bool isCallValid =
11951 (context->skipValidation() ||
11952 ValidateIsRenderbufferOES(context, angle::EntryPoint::GLIsRenderbufferOES,
11953 renderbufferPacked));
11954 if (isCallValid)
11955 {
11956 returnValue = context->isRenderbuffer(renderbufferPacked);
11957 }
11958 else
11959 {
11960 returnValue =
11961 GetDefaultReturnValue<angle::EntryPoint::GLIsRenderbufferOES, GLboolean>();
11962 }
11963 ANGLE_CAPTURE_GL(IsRenderbufferOES, isCallValid, context, renderbufferPacked, returnValue);
11964 }
11965 else
11966 {
11967 GenerateContextLostErrorOnCurrentGlobalContext();
11968 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsRenderbufferOES, GLboolean>();
11969 }
11970 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
11971 return returnValue;
11972 }
11973
GL_RenderbufferStorageOES(GLenum target,GLenum internalformat,GLsizei width,GLsizei height)11974 void GL_APIENTRY GL_RenderbufferStorageOES(GLenum target,
11975 GLenum internalformat,
11976 GLsizei width,
11977 GLsizei height)
11978 {
11979 Context *context = GetValidGlobalContext();
11980 EVENT(context, GLRenderbufferStorageOES,
11981 "context = %d, target = %s, internalformat = %s, width = %d, height = %d", CID(context),
11982 GLenumToString(GLESEnum::RenderbufferTarget, target),
11983 GLenumToString(GLESEnum::InternalFormat, internalformat), width, height);
11984
11985 if (context)
11986 {
11987 SCOPED_SHARE_CONTEXT_LOCK(context);
11988 bool isCallValid =
11989 (context->skipValidation() ||
11990 ValidateRenderbufferStorageOES(context, angle::EntryPoint::GLRenderbufferStorageOES,
11991 target, internalformat, width, height));
11992 if (isCallValid)
11993 {
11994 context->renderbufferStorage(target, internalformat, width, height);
11995 }
11996 ANGLE_CAPTURE_GL(RenderbufferStorageOES, isCallValid, context, target, internalformat,
11997 width, height);
11998 }
11999 else
12000 {
12001 GenerateContextLostErrorOnCurrentGlobalContext();
12002 }
12003 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12004 }
12005
12006 // GL_OES_geometry_shader
GL_FramebufferTextureOES(GLenum target,GLenum attachment,GLuint texture,GLint level)12007 void GL_APIENTRY GL_FramebufferTextureOES(GLenum target,
12008 GLenum attachment,
12009 GLuint texture,
12010 GLint level)
12011 {
12012 Context *context = GetValidGlobalContext();
12013 EVENT(context, GLFramebufferTextureOES,
12014 "context = %d, target = %s, attachment = %s, texture = %u, level = %d", CID(context),
12015 GLenumToString(GLESEnum::FramebufferTarget, target),
12016 GLenumToString(GLESEnum::FramebufferAttachment, attachment), texture, level);
12017
12018 if (context)
12019 {
12020 TextureID texturePacked = PackParam<TextureID>(texture);
12021 SCOPED_SHARE_CONTEXT_LOCK(context);
12022 bool isCallValid =
12023 (context->skipValidation() ||
12024 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12025 context->getMutableErrorSetForValidation(),
12026 angle::EntryPoint::GLFramebufferTextureOES) &&
12027 ValidateFramebufferTextureOES(context, angle::EntryPoint::GLFramebufferTextureOES,
12028 target, attachment, texturePacked, level)));
12029 if (isCallValid)
12030 {
12031 context->framebufferTexture(target, attachment, texturePacked, level);
12032 }
12033 ANGLE_CAPTURE_GL(FramebufferTextureOES, isCallValid, context, target, attachment,
12034 texturePacked, level);
12035 }
12036 else
12037 {
12038 GenerateContextLostErrorOnCurrentGlobalContext();
12039 }
12040 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12041 }
12042
12043 // GL_OES_get_program_binary
GL_GetProgramBinaryOES(GLuint program,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)12044 void GL_APIENTRY GL_GetProgramBinaryOES(GLuint program,
12045 GLsizei bufSize,
12046 GLsizei *length,
12047 GLenum *binaryFormat,
12048 void *binary)
12049 {
12050 Context *context = GetValidGlobalContext();
12051 EVENT(context, GLGetProgramBinaryOES,
12052 "context = %d, program = %u, bufSize = %d, length = 0x%016" PRIxPTR
12053 ", binaryFormat = 0x%016" PRIxPTR ", binary = 0x%016" PRIxPTR "",
12054 CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat,
12055 (uintptr_t)binary);
12056
12057 if (context)
12058 {
12059 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
12060 SCOPED_SHARE_CONTEXT_LOCK(context);
12061 bool isCallValid =
12062 (context->skipValidation() ||
12063 ValidateGetProgramBinaryOES(context, angle::EntryPoint::GLGetProgramBinaryOES,
12064 programPacked, bufSize, length, binaryFormat, binary));
12065 if (isCallValid)
12066 {
12067 context->getProgramBinary(programPacked, bufSize, length, binaryFormat, binary);
12068 }
12069 ANGLE_CAPTURE_GL(GetProgramBinaryOES, isCallValid, context, programPacked, bufSize, length,
12070 binaryFormat, binary);
12071 }
12072 else
12073 {
12074 GenerateContextLostErrorOnCurrentGlobalContext();
12075 }
12076 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12077 }
12078
GL_ProgramBinaryOES(GLuint program,GLenum binaryFormat,const void * binary,GLint length)12079 void GL_APIENTRY GL_ProgramBinaryOES(GLuint program,
12080 GLenum binaryFormat,
12081 const void *binary,
12082 GLint length)
12083 {
12084 Context *context = GetValidGlobalContext();
12085 EVENT(context, GLProgramBinaryOES,
12086 "context = %d, program = %u, binaryFormat = %s, binary = 0x%016" PRIxPTR ", length = %d",
12087 CID(context), program, GLenumToString(GLESEnum::AllEnums, binaryFormat),
12088 (uintptr_t)binary, length);
12089
12090 if (context)
12091 {
12092 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
12093 SCOPED_SHARE_CONTEXT_LOCK(context);
12094 bool isCallValid =
12095 (context->skipValidation() ||
12096 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12097 context->getMutableErrorSetForValidation(),
12098 angle::EntryPoint::GLProgramBinaryOES) &&
12099 ValidateProgramBinaryOES(context, angle::EntryPoint::GLProgramBinaryOES,
12100 programPacked, binaryFormat, binary, length)));
12101 if (isCallValid)
12102 {
12103 context->programBinary(programPacked, binaryFormat, binary, length);
12104 }
12105 ANGLE_CAPTURE_GL(ProgramBinaryOES, isCallValid, context, programPacked, binaryFormat,
12106 binary, length);
12107 }
12108 else
12109 {
12110 GenerateContextLostErrorOnCurrentGlobalContext();
12111 }
12112 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12113 }
12114
12115 // GL_OES_gpu_shader5
12116
12117 // GL_OES_mapbuffer
GL_GetBufferPointervOES(GLenum target,GLenum pname,void ** params)12118 void GL_APIENTRY GL_GetBufferPointervOES(GLenum target, GLenum pname, void **params)
12119 {
12120 Context *context = GetValidGlobalContext();
12121 EVENT(context, GLGetBufferPointervOES,
12122 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
12123 GLenumToString(GLESEnum::BufferTargetARB, target),
12124 GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params);
12125
12126 if (context)
12127 {
12128 BufferBinding targetPacked = PackParam<BufferBinding>(target);
12129 SCOPED_SHARE_CONTEXT_LOCK(context);
12130 bool isCallValid =
12131 (context->skipValidation() ||
12132 ValidateGetBufferPointervOES(context, angle::EntryPoint::GLGetBufferPointervOES,
12133 targetPacked, pname, params));
12134 if (isCallValid)
12135 {
12136 context->getBufferPointerv(targetPacked, pname, params);
12137 }
12138 ANGLE_CAPTURE_GL(GetBufferPointervOES, isCallValid, context, targetPacked, pname, params);
12139 }
12140 else
12141 {
12142 GenerateContextLostErrorOnCurrentGlobalContext();
12143 }
12144 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12145 }
12146
GL_MapBufferOES(GLenum target,GLenum access)12147 void *GL_APIENTRY GL_MapBufferOES(GLenum target, GLenum access)
12148 {
12149 Context *context = GetValidGlobalContext();
12150 EVENT(context, GLMapBufferOES, "context = %d, target = %s, access = %s", CID(context),
12151 GLenumToString(GLESEnum::BufferTargetARB, target),
12152 GLenumToString(GLESEnum::BufferAccessARB, access));
12153
12154 void *returnValue;
12155 if (context)
12156 {
12157 BufferBinding targetPacked = PackParam<BufferBinding>(target);
12158 SCOPED_SHARE_CONTEXT_LOCK(context);
12159 bool isCallValid =
12160 (context->skipValidation() ||
12161 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12162 context->getMutableErrorSetForValidation(),
12163 angle::EntryPoint::GLMapBufferOES) &&
12164 ValidateMapBufferOES(context, angle::EntryPoint::GLMapBufferOES, targetPacked,
12165 access)));
12166 if (isCallValid)
12167 {
12168 returnValue = context->mapBuffer(targetPacked, access);
12169 }
12170 else
12171 {
12172 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferOES, void *>();
12173 }
12174 ANGLE_CAPTURE_GL(MapBufferOES, isCallValid, context, targetPacked, access, returnValue);
12175 }
12176 else
12177 {
12178 GenerateContextLostErrorOnCurrentGlobalContext();
12179 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferOES, void *>();
12180 }
12181 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12182 return returnValue;
12183 }
12184
GL_UnmapBufferOES(GLenum target)12185 GLboolean GL_APIENTRY GL_UnmapBufferOES(GLenum target)
12186 {
12187 Context *context = GetValidGlobalContext();
12188 EVENT(context, GLUnmapBufferOES, "context = %d, target = %s", CID(context),
12189 GLenumToString(GLESEnum::AllEnums, target));
12190
12191 GLboolean returnValue;
12192 if (context)
12193 {
12194 BufferBinding targetPacked = PackParam<BufferBinding>(target);
12195 SCOPED_SHARE_CONTEXT_LOCK(context);
12196 bool isCallValid =
12197 (context->skipValidation() ||
12198 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12199 context->getMutableErrorSetForValidation(),
12200 angle::EntryPoint::GLUnmapBufferOES) &&
12201 ValidateUnmapBufferOES(context, angle::EntryPoint::GLUnmapBufferOES, targetPacked)));
12202 if (isCallValid)
12203 {
12204 returnValue = context->unmapBuffer(targetPacked);
12205 }
12206 else
12207 {
12208 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLUnmapBufferOES, GLboolean>();
12209 }
12210 ANGLE_CAPTURE_GL(UnmapBufferOES, isCallValid, context, targetPacked, returnValue);
12211 }
12212 else
12213 {
12214 GenerateContextLostErrorOnCurrentGlobalContext();
12215 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLUnmapBufferOES, GLboolean>();
12216 }
12217 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12218 return returnValue;
12219 }
12220
12221 // GL_OES_matrix_palette
GL_CurrentPaletteMatrixOES(GLuint matrixpaletteindex)12222 void GL_APIENTRY GL_CurrentPaletteMatrixOES(GLuint matrixpaletteindex)
12223 {
12224 Context *context = GetValidGlobalContext();
12225 EVENT(context, GLCurrentPaletteMatrixOES, "context = %d, matrixpaletteindex = %u", CID(context),
12226 matrixpaletteindex);
12227
12228 if (context)
12229 {
12230 SCOPED_SHARE_CONTEXT_LOCK(context);
12231 bool isCallValid =
12232 (context->skipValidation() ||
12233 ValidateCurrentPaletteMatrixOES(context, angle::EntryPoint::GLCurrentPaletteMatrixOES,
12234 matrixpaletteindex));
12235 if (isCallValid)
12236 {
12237 context->currentPaletteMatrix(matrixpaletteindex);
12238 }
12239 ANGLE_CAPTURE_GL(CurrentPaletteMatrixOES, isCallValid, context, matrixpaletteindex);
12240 }
12241 else
12242 {
12243 GenerateContextLostErrorOnCurrentGlobalContext();
12244 }
12245 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12246 }
12247
GL_LoadPaletteFromModelViewMatrixOES()12248 void GL_APIENTRY GL_LoadPaletteFromModelViewMatrixOES()
12249 {
12250 Context *context = GetValidGlobalContext();
12251 EVENT(context, GLLoadPaletteFromModelViewMatrixOES, "context = %d", CID(context));
12252
12253 if (context)
12254 {
12255 SCOPED_SHARE_CONTEXT_LOCK(context);
12256 bool isCallValid = (context->skipValidation() ||
12257 ValidateLoadPaletteFromModelViewMatrixOES(
12258 context, angle::EntryPoint::GLLoadPaletteFromModelViewMatrixOES));
12259 if (isCallValid)
12260 {
12261 context->loadPaletteFromModelViewMatrix();
12262 }
12263 ANGLE_CAPTURE_GL(LoadPaletteFromModelViewMatrixOES, isCallValid, context);
12264 }
12265 else
12266 {
12267 GenerateContextLostErrorOnCurrentGlobalContext();
12268 }
12269 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12270 }
12271
GL_MatrixIndexPointerOES(GLint size,GLenum type,GLsizei stride,const void * pointer)12272 void GL_APIENTRY GL_MatrixIndexPointerOES(GLint size,
12273 GLenum type,
12274 GLsizei stride,
12275 const void *pointer)
12276 {
12277 Context *context = GetValidGlobalContext();
12278 EVENT(context, GLMatrixIndexPointerOES,
12279 "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "",
12280 CID(context), size, GLenumToString(GLESEnum::AllEnums, type), stride, (uintptr_t)pointer);
12281
12282 if (context)
12283 {
12284 SCOPED_SHARE_CONTEXT_LOCK(context);
12285 bool isCallValid =
12286 (context->skipValidation() ||
12287 ValidateMatrixIndexPointerOES(context, angle::EntryPoint::GLMatrixIndexPointerOES,
12288 size, type, stride, pointer));
12289 if (isCallValid)
12290 {
12291 context->matrixIndexPointer(size, type, stride, pointer);
12292 }
12293 ANGLE_CAPTURE_GL(MatrixIndexPointerOES, isCallValid, context, size, type, stride, pointer);
12294 }
12295 else
12296 {
12297 GenerateContextLostErrorOnCurrentGlobalContext();
12298 }
12299 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12300 }
12301
GL_WeightPointerOES(GLint size,GLenum type,GLsizei stride,const void * pointer)12302 void GL_APIENTRY GL_WeightPointerOES(GLint size, GLenum type, GLsizei stride, const void *pointer)
12303 {
12304 Context *context = GetValidGlobalContext();
12305 EVENT(context, GLWeightPointerOES,
12306 "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "",
12307 CID(context), size, GLenumToString(GLESEnum::AllEnums, type), stride, (uintptr_t)pointer);
12308
12309 if (context)
12310 {
12311 SCOPED_SHARE_CONTEXT_LOCK(context);
12312 bool isCallValid = (context->skipValidation() ||
12313 ValidateWeightPointerOES(context, angle::EntryPoint::GLWeightPointerOES,
12314 size, type, stride, pointer));
12315 if (isCallValid)
12316 {
12317 context->weightPointer(size, type, stride, pointer);
12318 }
12319 ANGLE_CAPTURE_GL(WeightPointerOES, isCallValid, context, size, type, stride, pointer);
12320 }
12321 else
12322 {
12323 GenerateContextLostErrorOnCurrentGlobalContext();
12324 }
12325 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12326 }
12327
12328 // GL_OES_packed_depth_stencil
12329
12330 // GL_OES_point_size_array
GL_PointSizePointerOES(GLenum type,GLsizei stride,const void * pointer)12331 void GL_APIENTRY GL_PointSizePointerOES(GLenum type, GLsizei stride, const void *pointer)
12332 {
12333 Context *context = GetValidGlobalContext();
12334 EVENT(context, GLPointSizePointerOES,
12335 "context = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context),
12336 GLenumToString(GLESEnum::AllEnums, type), stride, (uintptr_t)pointer);
12337
12338 if (context)
12339 {
12340 VertexAttribType typePacked = PackParam<VertexAttribType>(type);
12341 SCOPED_SHARE_CONTEXT_LOCK(context);
12342 bool isCallValid =
12343 (context->skipValidation() ||
12344 ValidatePointSizePointerOES(context, angle::EntryPoint::GLPointSizePointerOES,
12345 typePacked, stride, pointer));
12346 if (isCallValid)
12347 {
12348 context->pointSizePointer(typePacked, stride, pointer);
12349 }
12350 ANGLE_CAPTURE_GL(PointSizePointerOES, isCallValid, context, typePacked, stride, pointer);
12351 }
12352 else
12353 {
12354 GenerateContextLostErrorOnCurrentGlobalContext();
12355 }
12356 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12357 }
12358
12359 // GL_OES_point_sprite
12360
12361 // GL_OES_primitive_bounding_box
GL_PrimitiveBoundingBoxOES(GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW)12362 void GL_APIENTRY GL_PrimitiveBoundingBoxOES(GLfloat minX,
12363 GLfloat minY,
12364 GLfloat minZ,
12365 GLfloat minW,
12366 GLfloat maxX,
12367 GLfloat maxY,
12368 GLfloat maxZ,
12369 GLfloat maxW)
12370 {
12371 Context *context = GetValidGlobalContext();
12372 EVENT(context, GLPrimitiveBoundingBoxOES,
12373 "context = %d, minX = %f, minY = %f, minZ = %f, minW = %f, maxX = %f, maxY = %f, maxZ = "
12374 "%f, maxW = %f",
12375 CID(context), minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
12376
12377 if (context)
12378 {
12379 bool isCallValid =
12380 (context->skipValidation() ||
12381 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12382 context->getMutableErrorSetForValidation(),
12383 angle::EntryPoint::GLPrimitiveBoundingBoxOES) &&
12384 ValidatePrimitiveBoundingBoxOES(context->getPrivateState(),
12385 context->getMutableErrorSetForValidation(),
12386 angle::EntryPoint::GLPrimitiveBoundingBoxOES, minX,
12387 minY, minZ, minW, maxX, maxY, maxZ, maxW)));
12388 if (isCallValid)
12389 {
12390 ContextPrivatePrimitiveBoundingBox(context->getMutablePrivateState(),
12391 context->getMutablePrivateStateCache(), minX, minY,
12392 minZ, minW, maxX, maxY, maxZ, maxW);
12393 }
12394 ANGLE_CAPTURE_GL(PrimitiveBoundingBoxOES, isCallValid, context, minX, minY, minZ, minW,
12395 maxX, maxY, maxZ, maxW);
12396 }
12397 else
12398 {
12399 GenerateContextLostErrorOnCurrentGlobalContext();
12400 }
12401 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12402 }
12403
12404 // GL_OES_query_matrix
GL_QueryMatrixxOES(GLfixed * mantissa,GLint * exponent)12405 GLbitfield GL_APIENTRY GL_QueryMatrixxOES(GLfixed *mantissa, GLint *exponent)
12406 {
12407 Context *context = GetValidGlobalContext();
12408 EVENT(context, GLQueryMatrixxOES,
12409 "context = %d, mantissa = 0x%016" PRIxPTR ", exponent = 0x%016" PRIxPTR "", CID(context),
12410 (uintptr_t)mantissa, (uintptr_t)exponent);
12411
12412 GLbitfield returnValue;
12413 if (context)
12414 {
12415 SCOPED_SHARE_CONTEXT_LOCK(context);
12416 bool isCallValid = (context->skipValidation() ||
12417 ValidateQueryMatrixxOES(context, angle::EntryPoint::GLQueryMatrixxOES,
12418 mantissa, exponent));
12419 if (isCallValid)
12420 {
12421 returnValue = context->queryMatrixx(mantissa, exponent);
12422 }
12423 else
12424 {
12425 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLQueryMatrixxOES, GLbitfield>();
12426 }
12427 ANGLE_CAPTURE_GL(QueryMatrixxOES, isCallValid, context, mantissa, exponent, returnValue);
12428 }
12429 else
12430 {
12431 GenerateContextLostErrorOnCurrentGlobalContext();
12432 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLQueryMatrixxOES, GLbitfield>();
12433 }
12434 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12435 return returnValue;
12436 }
12437
12438 // GL_OES_rgb8_rgba8
12439
12440 // GL_OES_sample_shading
GL_MinSampleShadingOES(GLfloat value)12441 void GL_APIENTRY GL_MinSampleShadingOES(GLfloat value)
12442 {
12443 Context *context = GetValidGlobalContext();
12444 EVENT(context, GLMinSampleShadingOES, "context = %d, value = %f", CID(context), value);
12445
12446 if (context)
12447 {
12448 bool isCallValid =
12449 (context->skipValidation() ||
12450 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12451 context->getMutableErrorSetForValidation(),
12452 angle::EntryPoint::GLMinSampleShadingOES) &&
12453 ValidateMinSampleShadingOES(context->getPrivateState(),
12454 context->getMutableErrorSetForValidation(),
12455 angle::EntryPoint::GLMinSampleShadingOES, value)));
12456 if (isCallValid)
12457 {
12458 ContextPrivateMinSampleShading(context->getMutablePrivateState(),
12459 context->getMutablePrivateStateCache(), value);
12460 }
12461 ANGLE_CAPTURE_GL(MinSampleShadingOES, isCallValid, context, value);
12462 }
12463 else
12464 {
12465 GenerateContextLostErrorOnCurrentGlobalContext();
12466 }
12467 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12468 }
12469
12470 // GL_OES_sample_variables
12471
12472 // GL_OES_shader_image_atomic
12473
12474 // GL_OES_shader_io_blocks
12475
12476 // GL_OES_shader_multisample_interpolation
12477
12478 // GL_OES_standard_derivatives
12479
12480 // GL_OES_surfaceless_context
12481
12482 // GL_OES_tessellation_shader
GL_PatchParameteriOES(GLenum pname,GLint value)12483 void GL_APIENTRY GL_PatchParameteriOES(GLenum pname, GLint value)
12484 {
12485 Context *context = GetValidGlobalContext();
12486 EVENT(context, GLPatchParameteriOES, "context = %d, pname = %s, value = %d", CID(context),
12487 GLenumToString(GLESEnum::PatchParameterName, pname), value);
12488
12489 if (context)
12490 {
12491 bool isCallValid =
12492 (context->skipValidation() ||
12493 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12494 context->getMutableErrorSetForValidation(),
12495 angle::EntryPoint::GLPatchParameteriOES) &&
12496 ValidatePatchParameteriOES(context->getPrivateState(),
12497 context->getMutableErrorSetForValidation(),
12498 angle::EntryPoint::GLPatchParameteriOES, pname, value)));
12499 if (isCallValid)
12500 {
12501 ContextPrivatePatchParameteri(context->getMutablePrivateState(),
12502 context->getMutablePrivateStateCache(), pname, value);
12503 }
12504 ANGLE_CAPTURE_GL(PatchParameteriOES, isCallValid, context, pname, value);
12505 }
12506 else
12507 {
12508 GenerateContextLostErrorOnCurrentGlobalContext();
12509 }
12510 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12511 }
12512
12513 // 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)12514 void GL_APIENTRY GL_CompressedTexImage3DOES(GLenum target,
12515 GLint level,
12516 GLenum internalformat,
12517 GLsizei width,
12518 GLsizei height,
12519 GLsizei depth,
12520 GLint border,
12521 GLsizei imageSize,
12522 const void *data)
12523 {
12524 Context *context = GetValidGlobalContext();
12525 EVENT(context, GLCompressedTexImage3DOES,
12526 "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
12527 "depth = %d, border = %d, imageSize = %d, data = 0x%016" PRIxPTR "",
12528 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level,
12529 GLenumToString(GLESEnum::InternalFormat, internalformat), width, height, depth, border,
12530 imageSize, (uintptr_t)data);
12531
12532 if (context)
12533 {
12534 TextureTarget targetPacked = PackParam<TextureTarget>(target);
12535 SCOPED_SHARE_CONTEXT_LOCK(context);
12536 bool isCallValid =
12537 (context->skipValidation() ||
12538 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12539 context->getMutableErrorSetForValidation(),
12540 angle::EntryPoint::GLCompressedTexImage3DOES) &&
12541 ValidateCompressedTexImage3DOES(context, angle::EntryPoint::GLCompressedTexImage3DOES,
12542 targetPacked, level, internalformat, width, height,
12543 depth, border, imageSize, data)));
12544 if (isCallValid)
12545 {
12546 context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth,
12547 border, imageSize, data);
12548 }
12549 ANGLE_CAPTURE_GL(CompressedTexImage3DOES, isCallValid, context, targetPacked, level,
12550 internalformat, width, height, depth, border, imageSize, data);
12551 }
12552 else
12553 {
12554 GenerateContextLostErrorOnCurrentGlobalContext();
12555 }
12556 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
12557 }
12558
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)12559 void GL_APIENTRY GL_CompressedTexSubImage3DOES(GLenum target,
12560 GLint level,
12561 GLint xoffset,
12562 GLint yoffset,
12563 GLint zoffset,
12564 GLsizei width,
12565 GLsizei height,
12566 GLsizei depth,
12567 GLenum format,
12568 GLsizei imageSize,
12569 const void *data)
12570 {
12571 Context *context = GetValidGlobalContext();
12572 EVENT(context, GLCompressedTexSubImage3DOES,
12573 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width "
12574 "= %d, height = %d, depth = %d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "",
12575 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset,
12576 zoffset, width, height, depth, GLenumToString(GLESEnum::InternalFormat, format),
12577 imageSize, (uintptr_t)data);
12578
12579 if (context)
12580 {
12581 TextureTarget targetPacked = PackParam<TextureTarget>(target);
12582 SCOPED_SHARE_CONTEXT_LOCK(context);
12583 bool isCallValid =
12584 (context->skipValidation() ||
12585 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12586 context->getMutableErrorSetForValidation(),
12587 angle::EntryPoint::GLCompressedTexSubImage3DOES) &&
12588 ValidateCompressedTexSubImage3DOES(
12589 context, angle::EntryPoint::GLCompressedTexSubImage3DOES, targetPacked, level,
12590 xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)));
12591 if (isCallValid)
12592 {
12593 context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width,
12594 height, depth, format, imageSize, data);
12595 }
12596 ANGLE_CAPTURE_GL(CompressedTexSubImage3DOES, isCallValid, context, targetPacked, level,
12597 xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
12598 }
12599 else
12600 {
12601 GenerateContextLostErrorOnCurrentGlobalContext();
12602 }
12603 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
12604 }
12605
GL_CopyTexSubImage3DOES(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)12606 void GL_APIENTRY GL_CopyTexSubImage3DOES(GLenum target,
12607 GLint level,
12608 GLint xoffset,
12609 GLint yoffset,
12610 GLint zoffset,
12611 GLint x,
12612 GLint y,
12613 GLsizei width,
12614 GLsizei height)
12615 {
12616 Context *context = GetValidGlobalContext();
12617 EVENT(context, GLCopyTexSubImage3DOES,
12618 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, x = "
12619 "%d, y = %d, width = %d, height = %d",
12620 CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset,
12621 zoffset, x, y, width, height);
12622
12623 if (context)
12624 {
12625 TextureTarget targetPacked = PackParam<TextureTarget>(target);
12626 SCOPED_SHARE_CONTEXT_LOCK(context);
12627 bool isCallValid =
12628 (context->skipValidation() ||
12629 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12630 context->getMutableErrorSetForValidation(),
12631 angle::EntryPoint::GLCopyTexSubImage3DOES) &&
12632 ValidateCopyTexSubImage3DOES(context, angle::EntryPoint::GLCopyTexSubImage3DOES,
12633 targetPacked, level, xoffset, yoffset, zoffset, x, y,
12634 width, height)));
12635 if (isCallValid)
12636 {
12637 context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
12638 height);
12639 }
12640 ANGLE_CAPTURE_GL(CopyTexSubImage3DOES, isCallValid, context, targetPacked, level, xoffset,
12641 yoffset, zoffset, x, y, width, height);
12642 }
12643 else
12644 {
12645 GenerateContextLostErrorOnCurrentGlobalContext();
12646 }
12647 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12648 }
12649
GL_FramebufferTexture3DOES(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset)12650 void GL_APIENTRY GL_FramebufferTexture3DOES(GLenum target,
12651 GLenum attachment,
12652 GLenum textarget,
12653 GLuint texture,
12654 GLint level,
12655 GLint zoffset)
12656 {
12657 Context *context = GetValidGlobalContext();
12658 EVENT(context, GLFramebufferTexture3DOES,
12659 "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, "
12660 "zoffset = %d",
12661 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
12662 GLenumToString(GLESEnum::FramebufferAttachment, attachment),
12663 GLenumToString(GLESEnum::TextureTarget, textarget), texture, level, zoffset);
12664
12665 if (context)
12666 {
12667 TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
12668 TextureID texturePacked = PackParam<TextureID>(texture);
12669 SCOPED_SHARE_CONTEXT_LOCK(context);
12670 bool isCallValid =
12671 (context->skipValidation() ||
12672 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12673 context->getMutableErrorSetForValidation(),
12674 angle::EntryPoint::GLFramebufferTexture3DOES) &&
12675 ValidateFramebufferTexture3DOES(context, angle::EntryPoint::GLFramebufferTexture3DOES,
12676 target, attachment, textargetPacked, texturePacked,
12677 level, zoffset)));
12678 if (isCallValid)
12679 {
12680 context->framebufferTexture3D(target, attachment, textargetPacked, texturePacked, level,
12681 zoffset);
12682 }
12683 ANGLE_CAPTURE_GL(FramebufferTexture3DOES, isCallValid, context, target, attachment,
12684 textargetPacked, texturePacked, level, zoffset);
12685 }
12686 else
12687 {
12688 GenerateContextLostErrorOnCurrentGlobalContext();
12689 }
12690 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12691 }
12692
GL_TexImage3DOES(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void * pixels)12693 void GL_APIENTRY GL_TexImage3DOES(GLenum target,
12694 GLint level,
12695 GLenum internalformat,
12696 GLsizei width,
12697 GLsizei height,
12698 GLsizei depth,
12699 GLint border,
12700 GLenum format,
12701 GLenum type,
12702 const void *pixels)
12703 {
12704 Context *context = GetValidGlobalContext();
12705 EVENT(context, GLTexImage3DOES,
12706 "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
12707 "depth = %d, border = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
12708 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level,
12709 GLenumToString(GLESEnum::InternalFormat, internalformat), width, height, depth, border,
12710 GLenumToString(GLESEnum::PixelFormat, format), GLenumToString(GLESEnum::PixelType, type),
12711 (uintptr_t)pixels);
12712
12713 if (context)
12714 {
12715 TextureTarget targetPacked = PackParam<TextureTarget>(target);
12716 SCOPED_SHARE_CONTEXT_LOCK(context);
12717 bool isCallValid =
12718 (context->skipValidation() ||
12719 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12720 context->getMutableErrorSetForValidation(),
12721 angle::EntryPoint::GLTexImage3DOES) &&
12722 ValidateTexImage3DOES(context, angle::EntryPoint::GLTexImage3DOES, targetPacked,
12723 level, internalformat, width, height, depth, border, format,
12724 type, pixels)));
12725 if (isCallValid)
12726 {
12727 context->texImage3D(targetPacked, level, internalformat, width, height, depth, border,
12728 format, type, pixels);
12729 }
12730 ANGLE_CAPTURE_GL(TexImage3DOES, isCallValid, context, targetPacked, level, internalformat,
12731 width, height, depth, border, format, type, pixels);
12732 }
12733 else
12734 {
12735 GenerateContextLostErrorOnCurrentGlobalContext();
12736 }
12737 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
12738 }
12739
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)12740 void GL_APIENTRY GL_TexSubImage3DOES(GLenum target,
12741 GLint level,
12742 GLint xoffset,
12743 GLint yoffset,
12744 GLint zoffset,
12745 GLsizei width,
12746 GLsizei height,
12747 GLsizei depth,
12748 GLenum format,
12749 GLenum type,
12750 const void *pixels)
12751 {
12752 Context *context = GetValidGlobalContext();
12753 EVENT(context, GLTexSubImage3DOES,
12754 "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width "
12755 "= %d, height = %d, depth = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
12756 CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset,
12757 zoffset, width, height, depth, GLenumToString(GLESEnum::PixelFormat, format),
12758 GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels);
12759
12760 if (context)
12761 {
12762 TextureTarget targetPacked = PackParam<TextureTarget>(target);
12763 SCOPED_SHARE_CONTEXT_LOCK(context);
12764 bool isCallValid =
12765 (context->skipValidation() ||
12766 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
12767 context->getMutableErrorSetForValidation(),
12768 angle::EntryPoint::GLTexSubImage3DOES) &&
12769 ValidateTexSubImage3DOES(context, angle::EntryPoint::GLTexSubImage3DOES, targetPacked,
12770 level, xoffset, yoffset, zoffset, width, height, depth,
12771 format, type, pixels)));
12772 if (isCallValid)
12773 {
12774 context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height,
12775 depth, format, type, pixels);
12776 }
12777 ANGLE_CAPTURE_GL(TexSubImage3DOES, isCallValid, context, targetPacked, level, xoffset,
12778 yoffset, zoffset, width, height, depth, format, type, pixels);
12779 }
12780 else
12781 {
12782 GenerateContextLostErrorOnCurrentGlobalContext();
12783 }
12784 egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
12785 }
12786
12787 // GL_OES_texture_border_clamp
GL_GetSamplerParameterIivOES(GLuint sampler,GLenum pname,GLint * params)12788 void GL_APIENTRY GL_GetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLint *params)
12789 {
12790 Context *context = GetValidGlobalContext();
12791 EVENT(context, GLGetSamplerParameterIivOES,
12792 "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
12793 sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params);
12794
12795 if (context)
12796 {
12797 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
12798 SCOPED_SHARE_CONTEXT_LOCK(context);
12799 bool isCallValid = (context->skipValidation() ||
12800 ValidateGetSamplerParameterIivOES(
12801 context, angle::EntryPoint::GLGetSamplerParameterIivOES,
12802 samplerPacked, pname, params));
12803 if (isCallValid)
12804 {
12805 context->getSamplerParameterIiv(samplerPacked, pname, params);
12806 }
12807 ANGLE_CAPTURE_GL(GetSamplerParameterIivOES, isCallValid, context, samplerPacked, pname,
12808 params);
12809 }
12810 else
12811 {
12812 GenerateContextLostErrorOnCurrentGlobalContext();
12813 }
12814 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12815 }
12816
GL_GetSamplerParameterIuivOES(GLuint sampler,GLenum pname,GLuint * params)12817 void GL_APIENTRY GL_GetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLuint *params)
12818 {
12819 Context *context = GetValidGlobalContext();
12820 EVENT(context, GLGetSamplerParameterIuivOES,
12821 "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
12822 sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params);
12823
12824 if (context)
12825 {
12826 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
12827 SCOPED_SHARE_CONTEXT_LOCK(context);
12828 bool isCallValid = (context->skipValidation() ||
12829 ValidateGetSamplerParameterIuivOES(
12830 context, angle::EntryPoint::GLGetSamplerParameterIuivOES,
12831 samplerPacked, pname, params));
12832 if (isCallValid)
12833 {
12834 context->getSamplerParameterIuiv(samplerPacked, pname, params);
12835 }
12836 ANGLE_CAPTURE_GL(GetSamplerParameterIuivOES, isCallValid, context, samplerPacked, pname,
12837 params);
12838 }
12839 else
12840 {
12841 GenerateContextLostErrorOnCurrentGlobalContext();
12842 }
12843 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12844 }
12845
GL_GetTexParameterIivOES(GLenum target,GLenum pname,GLint * params)12846 void GL_APIENTRY GL_GetTexParameterIivOES(GLenum target, GLenum pname, GLint *params)
12847 {
12848 Context *context = GetValidGlobalContext();
12849 EVENT(context, GLGetTexParameterIivOES,
12850 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
12851 GLenumToString(GLESEnum::TextureTarget, target),
12852 GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params);
12853
12854 if (context)
12855 {
12856 TextureType targetPacked = PackParam<TextureType>(target);
12857 SCOPED_SHARE_CONTEXT_LOCK(context);
12858 bool isCallValid =
12859 (context->skipValidation() ||
12860 ValidateGetTexParameterIivOES(context, angle::EntryPoint::GLGetTexParameterIivOES,
12861 targetPacked, pname, params));
12862 if (isCallValid)
12863 {
12864 context->getTexParameterIiv(targetPacked, pname, params);
12865 }
12866 ANGLE_CAPTURE_GL(GetTexParameterIivOES, isCallValid, context, targetPacked, pname, params);
12867 }
12868 else
12869 {
12870 GenerateContextLostErrorOnCurrentGlobalContext();
12871 }
12872 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12873 }
12874
GL_GetTexParameterIuivOES(GLenum target,GLenum pname,GLuint * params)12875 void GL_APIENTRY GL_GetTexParameterIuivOES(GLenum target, GLenum pname, GLuint *params)
12876 {
12877 Context *context = GetValidGlobalContext();
12878 EVENT(context, GLGetTexParameterIuivOES,
12879 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
12880 GLenumToString(GLESEnum::TextureTarget, target),
12881 GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params);
12882
12883 if (context)
12884 {
12885 TextureType targetPacked = PackParam<TextureType>(target);
12886 SCOPED_SHARE_CONTEXT_LOCK(context);
12887 bool isCallValid =
12888 (context->skipValidation() ||
12889 ValidateGetTexParameterIuivOES(context, angle::EntryPoint::GLGetTexParameterIuivOES,
12890 targetPacked, pname, params));
12891 if (isCallValid)
12892 {
12893 context->getTexParameterIuiv(targetPacked, pname, params);
12894 }
12895 ANGLE_CAPTURE_GL(GetTexParameterIuivOES, isCallValid, context, targetPacked, pname, params);
12896 }
12897 else
12898 {
12899 GenerateContextLostErrorOnCurrentGlobalContext();
12900 }
12901 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12902 }
12903
GL_SamplerParameterIivOES(GLuint sampler,GLenum pname,const GLint * param)12904 void GL_APIENTRY GL_SamplerParameterIivOES(GLuint sampler, GLenum pname, const GLint *param)
12905 {
12906 Context *context = GetValidGlobalContext();
12907 EVENT(context, GLSamplerParameterIivOES,
12908 "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
12909 sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param);
12910
12911 if (context)
12912 {
12913 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
12914 SCOPED_SHARE_CONTEXT_LOCK(context);
12915 bool isCallValid =
12916 (context->skipValidation() ||
12917 ValidateSamplerParameterIivOES(context, angle::EntryPoint::GLSamplerParameterIivOES,
12918 samplerPacked, pname, param));
12919 if (isCallValid)
12920 {
12921 context->samplerParameterIiv(samplerPacked, pname, param);
12922 }
12923 ANGLE_CAPTURE_GL(SamplerParameterIivOES, isCallValid, context, samplerPacked, pname, param);
12924 }
12925 else
12926 {
12927 GenerateContextLostErrorOnCurrentGlobalContext();
12928 }
12929 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12930 }
12931
GL_SamplerParameterIuivOES(GLuint sampler,GLenum pname,const GLuint * param)12932 void GL_APIENTRY GL_SamplerParameterIuivOES(GLuint sampler, GLenum pname, const GLuint *param)
12933 {
12934 Context *context = GetValidGlobalContext();
12935 EVENT(context, GLSamplerParameterIuivOES,
12936 "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context),
12937 sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param);
12938
12939 if (context)
12940 {
12941 SamplerID samplerPacked = PackParam<SamplerID>(sampler);
12942 SCOPED_SHARE_CONTEXT_LOCK(context);
12943 bool isCallValid =
12944 (context->skipValidation() ||
12945 ValidateSamplerParameterIuivOES(context, angle::EntryPoint::GLSamplerParameterIuivOES,
12946 samplerPacked, pname, param));
12947 if (isCallValid)
12948 {
12949 context->samplerParameterIuiv(samplerPacked, pname, param);
12950 }
12951 ANGLE_CAPTURE_GL(SamplerParameterIuivOES, isCallValid, context, samplerPacked, pname,
12952 param);
12953 }
12954 else
12955 {
12956 GenerateContextLostErrorOnCurrentGlobalContext();
12957 }
12958 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12959 }
12960
GL_TexParameterIivOES(GLenum target,GLenum pname,const GLint * params)12961 void GL_APIENTRY GL_TexParameterIivOES(GLenum target, GLenum pname, const GLint *params)
12962 {
12963 Context *context = GetValidGlobalContext();
12964 EVENT(context, GLTexParameterIivOES,
12965 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
12966 GLenumToString(GLESEnum::TextureTarget, target),
12967 GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params);
12968
12969 if (context)
12970 {
12971 TextureType targetPacked = PackParam<TextureType>(target);
12972 SCOPED_SHARE_CONTEXT_LOCK(context);
12973 bool isCallValid =
12974 (context->skipValidation() ||
12975 ValidateTexParameterIivOES(context, angle::EntryPoint::GLTexParameterIivOES,
12976 targetPacked, pname, params));
12977 if (isCallValid)
12978 {
12979 context->texParameterIiv(targetPacked, pname, params);
12980 }
12981 ANGLE_CAPTURE_GL(TexParameterIivOES, isCallValid, context, targetPacked, pname, params);
12982 }
12983 else
12984 {
12985 GenerateContextLostErrorOnCurrentGlobalContext();
12986 }
12987 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
12988 }
12989
GL_TexParameterIuivOES(GLenum target,GLenum pname,const GLuint * params)12990 void GL_APIENTRY GL_TexParameterIuivOES(GLenum target, GLenum pname, const GLuint *params)
12991 {
12992 Context *context = GetValidGlobalContext();
12993 EVENT(context, GLTexParameterIuivOES,
12994 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
12995 GLenumToString(GLESEnum::TextureTarget, target),
12996 GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params);
12997
12998 if (context)
12999 {
13000 TextureType targetPacked = PackParam<TextureType>(target);
13001 SCOPED_SHARE_CONTEXT_LOCK(context);
13002 bool isCallValid =
13003 (context->skipValidation() ||
13004 ValidateTexParameterIuivOES(context, angle::EntryPoint::GLTexParameterIuivOES,
13005 targetPacked, pname, params));
13006 if (isCallValid)
13007 {
13008 context->texParameterIuiv(targetPacked, pname, params);
13009 }
13010 ANGLE_CAPTURE_GL(TexParameterIuivOES, isCallValid, context, targetPacked, pname, params);
13011 }
13012 else
13013 {
13014 GenerateContextLostErrorOnCurrentGlobalContext();
13015 }
13016 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13017 }
13018
13019 // GL_OES_texture_buffer
GL_TexBufferOES(GLenum target,GLenum internalformat,GLuint buffer)13020 void GL_APIENTRY GL_TexBufferOES(GLenum target, GLenum internalformat, GLuint buffer)
13021 {
13022 Context *context = GetValidGlobalContext();
13023 EVENT(context, GLTexBufferOES, "context = %d, target = %s, internalformat = %s, buffer = %u",
13024 CID(context), GLenumToString(GLESEnum::TextureTarget, target),
13025 GLenumToString(GLESEnum::SizedInternalFormat, internalformat), buffer);
13026
13027 if (context)
13028 {
13029 TextureType targetPacked = PackParam<TextureType>(target);
13030 BufferID bufferPacked = PackParam<BufferID>(buffer);
13031 SCOPED_SHARE_CONTEXT_LOCK(context);
13032 bool isCallValid =
13033 (context->skipValidation() ||
13034 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
13035 context->getMutableErrorSetForValidation(),
13036 angle::EntryPoint::GLTexBufferOES) &&
13037 ValidateTexBufferOES(context, angle::EntryPoint::GLTexBufferOES, targetPacked,
13038 internalformat, bufferPacked)));
13039 if (isCallValid)
13040 {
13041 context->texBuffer(targetPacked, internalformat, bufferPacked);
13042 }
13043 ANGLE_CAPTURE_GL(TexBufferOES, isCallValid, context, targetPacked, internalformat,
13044 bufferPacked);
13045 }
13046 else
13047 {
13048 GenerateContextLostErrorOnCurrentGlobalContext();
13049 }
13050 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13051 }
13052
GL_TexBufferRangeOES(GLenum target,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size)13053 void GL_APIENTRY GL_TexBufferRangeOES(GLenum target,
13054 GLenum internalformat,
13055 GLuint buffer,
13056 GLintptr offset,
13057 GLsizeiptr size)
13058 {
13059 Context *context = GetValidGlobalContext();
13060 EVENT(context, GLTexBufferRangeOES,
13061 "context = %d, target = %s, internalformat = %s, buffer = %u, offset = %llu, size = %llu",
13062 CID(context), GLenumToString(GLESEnum::TextureTarget, target),
13063 GLenumToString(GLESEnum::SizedInternalFormat, internalformat), buffer,
13064 static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size));
13065
13066 if (context)
13067 {
13068 TextureType targetPacked = PackParam<TextureType>(target);
13069 BufferID bufferPacked = PackParam<BufferID>(buffer);
13070 SCOPED_SHARE_CONTEXT_LOCK(context);
13071 bool isCallValid =
13072 (context->skipValidation() ||
13073 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
13074 context->getMutableErrorSetForValidation(),
13075 angle::EntryPoint::GLTexBufferRangeOES) &&
13076 ValidateTexBufferRangeOES(context, angle::EntryPoint::GLTexBufferRangeOES,
13077 targetPacked, internalformat, bufferPacked, offset, size)));
13078 if (isCallValid)
13079 {
13080 context->texBufferRange(targetPacked, internalformat, bufferPacked, offset, size);
13081 }
13082 ANGLE_CAPTURE_GL(TexBufferRangeOES, isCallValid, context, targetPacked, internalformat,
13083 bufferPacked, offset, size);
13084 }
13085 else
13086 {
13087 GenerateContextLostErrorOnCurrentGlobalContext();
13088 }
13089 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13090 }
13091
13092 // GL_OES_texture_compression_astc
13093
13094 // GL_OES_texture_cube_map
GL_GetTexGenfvOES(GLenum coord,GLenum pname,GLfloat * params)13095 void GL_APIENTRY GL_GetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params)
13096 {
13097 Context *context = GetValidGlobalContext();
13098 EVENT(context, GLGetTexGenfvOES,
13099 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
13100 GLenumToString(GLESEnum::TextureCoordName, coord),
13101 GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params);
13102
13103 if (context)
13104 {
13105 SCOPED_SHARE_CONTEXT_LOCK(context);
13106 bool isCallValid = (context->skipValidation() ||
13107 ValidateGetTexGenfvOES(context, angle::EntryPoint::GLGetTexGenfvOES,
13108 coord, pname, params));
13109 if (isCallValid)
13110 {
13111 context->getTexGenfv(coord, pname, params);
13112 }
13113 ANGLE_CAPTURE_GL(GetTexGenfvOES, isCallValid, context, coord, pname, params);
13114 }
13115 else
13116 {
13117 GenerateContextLostErrorOnCurrentGlobalContext();
13118 }
13119 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13120 }
13121
GL_GetTexGenivOES(GLenum coord,GLenum pname,GLint * params)13122 void GL_APIENTRY GL_GetTexGenivOES(GLenum coord, GLenum pname, GLint *params)
13123 {
13124 Context *context = GetValidGlobalContext();
13125 EVENT(context, GLGetTexGenivOES,
13126 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
13127 GLenumToString(GLESEnum::TextureCoordName, coord),
13128 GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params);
13129
13130 if (context)
13131 {
13132 SCOPED_SHARE_CONTEXT_LOCK(context);
13133 bool isCallValid = (context->skipValidation() ||
13134 ValidateGetTexGenivOES(context, angle::EntryPoint::GLGetTexGenivOES,
13135 coord, pname, params));
13136 if (isCallValid)
13137 {
13138 context->getTexGeniv(coord, pname, params);
13139 }
13140 ANGLE_CAPTURE_GL(GetTexGenivOES, isCallValid, context, coord, pname, params);
13141 }
13142 else
13143 {
13144 GenerateContextLostErrorOnCurrentGlobalContext();
13145 }
13146 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13147 }
13148
GL_GetTexGenxvOES(GLenum coord,GLenum pname,GLfixed * params)13149 void GL_APIENTRY GL_GetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
13150 {
13151 Context *context = GetValidGlobalContext();
13152 EVENT(context, GLGetTexGenxvOES,
13153 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
13154 GLenumToString(GLESEnum::TextureCoordName, coord),
13155 GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params);
13156
13157 if (context)
13158 {
13159 SCOPED_SHARE_CONTEXT_LOCK(context);
13160 bool isCallValid = (context->skipValidation() ||
13161 ValidateGetTexGenxvOES(context, angle::EntryPoint::GLGetTexGenxvOES,
13162 coord, pname, params));
13163 if (isCallValid)
13164 {
13165 context->getTexGenxv(coord, pname, params);
13166 }
13167 ANGLE_CAPTURE_GL(GetTexGenxvOES, isCallValid, context, coord, pname, params);
13168 }
13169 else
13170 {
13171 GenerateContextLostErrorOnCurrentGlobalContext();
13172 }
13173 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13174 }
13175
GL_TexGenfOES(GLenum coord,GLenum pname,GLfloat param)13176 void GL_APIENTRY GL_TexGenfOES(GLenum coord, GLenum pname, GLfloat param)
13177 {
13178 Context *context = GetValidGlobalContext();
13179 EVENT(context, GLTexGenfOES, "context = %d, coord = %s, pname = %s, param = %f", CID(context),
13180 GLenumToString(GLESEnum::TextureCoordName, coord),
13181 GLenumToString(GLESEnum::TextureGenParameter, pname), param);
13182
13183 if (context)
13184 {
13185 SCOPED_SHARE_CONTEXT_LOCK(context);
13186 bool isCallValid =
13187 (context->skipValidation() ||
13188 ValidateTexGenfOES(context, angle::EntryPoint::GLTexGenfOES, coord, pname, param));
13189 if (isCallValid)
13190 {
13191 context->texGenf(coord, pname, param);
13192 }
13193 ANGLE_CAPTURE_GL(TexGenfOES, isCallValid, context, coord, pname, param);
13194 }
13195 else
13196 {
13197 GenerateContextLostErrorOnCurrentGlobalContext();
13198 }
13199 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13200 }
13201
GL_TexGenfvOES(GLenum coord,GLenum pname,const GLfloat * params)13202 void GL_APIENTRY GL_TexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params)
13203 {
13204 Context *context = GetValidGlobalContext();
13205 EVENT(context, GLTexGenfvOES,
13206 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
13207 GLenumToString(GLESEnum::TextureCoordName, coord),
13208 GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params);
13209
13210 if (context)
13211 {
13212 SCOPED_SHARE_CONTEXT_LOCK(context);
13213 bool isCallValid =
13214 (context->skipValidation() ||
13215 ValidateTexGenfvOES(context, angle::EntryPoint::GLTexGenfvOES, coord, pname, params));
13216 if (isCallValid)
13217 {
13218 context->texGenfv(coord, pname, params);
13219 }
13220 ANGLE_CAPTURE_GL(TexGenfvOES, isCallValid, context, coord, pname, params);
13221 }
13222 else
13223 {
13224 GenerateContextLostErrorOnCurrentGlobalContext();
13225 }
13226 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13227 }
13228
GL_TexGeniOES(GLenum coord,GLenum pname,GLint param)13229 void GL_APIENTRY GL_TexGeniOES(GLenum coord, GLenum pname, GLint param)
13230 {
13231 Context *context = GetValidGlobalContext();
13232 EVENT(context, GLTexGeniOES, "context = %d, coord = %s, pname = %s, param = %d", CID(context),
13233 GLenumToString(GLESEnum::TextureCoordName, coord),
13234 GLenumToString(GLESEnum::TextureGenParameter, pname), param);
13235
13236 if (context)
13237 {
13238 SCOPED_SHARE_CONTEXT_LOCK(context);
13239 bool isCallValid =
13240 (context->skipValidation() ||
13241 ValidateTexGeniOES(context, angle::EntryPoint::GLTexGeniOES, coord, pname, param));
13242 if (isCallValid)
13243 {
13244 context->texGeni(coord, pname, param);
13245 }
13246 ANGLE_CAPTURE_GL(TexGeniOES, isCallValid, context, coord, pname, param);
13247 }
13248 else
13249 {
13250 GenerateContextLostErrorOnCurrentGlobalContext();
13251 }
13252 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13253 }
13254
GL_TexGenivOES(GLenum coord,GLenum pname,const GLint * params)13255 void GL_APIENTRY GL_TexGenivOES(GLenum coord, GLenum pname, const GLint *params)
13256 {
13257 Context *context = GetValidGlobalContext();
13258 EVENT(context, GLTexGenivOES,
13259 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
13260 GLenumToString(GLESEnum::TextureCoordName, coord),
13261 GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params);
13262
13263 if (context)
13264 {
13265 SCOPED_SHARE_CONTEXT_LOCK(context);
13266 bool isCallValid =
13267 (context->skipValidation() ||
13268 ValidateTexGenivOES(context, angle::EntryPoint::GLTexGenivOES, coord, pname, params));
13269 if (isCallValid)
13270 {
13271 context->texGeniv(coord, pname, params);
13272 }
13273 ANGLE_CAPTURE_GL(TexGenivOES, isCallValid, context, coord, pname, params);
13274 }
13275 else
13276 {
13277 GenerateContextLostErrorOnCurrentGlobalContext();
13278 }
13279 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13280 }
13281
GL_TexGenxOES(GLenum coord,GLenum pname,GLfixed param)13282 void GL_APIENTRY GL_TexGenxOES(GLenum coord, GLenum pname, GLfixed param)
13283 {
13284 Context *context = GetValidGlobalContext();
13285 EVENT(context, GLTexGenxOES, "context = %d, coord = %s, pname = %s, param = 0x%X", CID(context),
13286 GLenumToString(GLESEnum::TextureCoordName, coord),
13287 GLenumToString(GLESEnum::TextureGenParameter, pname), param);
13288
13289 if (context)
13290 {
13291 SCOPED_SHARE_CONTEXT_LOCK(context);
13292 bool isCallValid =
13293 (context->skipValidation() ||
13294 ValidateTexGenxOES(context, angle::EntryPoint::GLTexGenxOES, coord, pname, param));
13295 if (isCallValid)
13296 {
13297 context->texGenx(coord, pname, param);
13298 }
13299 ANGLE_CAPTURE_GL(TexGenxOES, isCallValid, context, coord, pname, param);
13300 }
13301 else
13302 {
13303 GenerateContextLostErrorOnCurrentGlobalContext();
13304 }
13305 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13306 }
13307
GL_TexGenxvOES(GLenum coord,GLenum pname,const GLfixed * params)13308 void GL_APIENTRY GL_TexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
13309 {
13310 Context *context = GetValidGlobalContext();
13311 EVENT(context, GLTexGenxvOES,
13312 "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
13313 GLenumToString(GLESEnum::TextureCoordName, coord),
13314 GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params);
13315
13316 if (context)
13317 {
13318 SCOPED_SHARE_CONTEXT_LOCK(context);
13319 bool isCallValid =
13320 (context->skipValidation() ||
13321 ValidateTexGenxvOES(context, angle::EntryPoint::GLTexGenxvOES, coord, pname, params));
13322 if (isCallValid)
13323 {
13324 context->texGenxv(coord, pname, params);
13325 }
13326 ANGLE_CAPTURE_GL(TexGenxvOES, isCallValid, context, coord, pname, params);
13327 }
13328 else
13329 {
13330 GenerateContextLostErrorOnCurrentGlobalContext();
13331 }
13332 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13333 }
13334
13335 // GL_OES_texture_cube_map_array
13336
13337 // GL_OES_texture_float
13338
13339 // GL_OES_texture_float_linear
13340
13341 // GL_OES_texture_half_float
13342
13343 // GL_OES_texture_half_float_linear
13344
13345 // GL_OES_texture_npot
13346
13347 // GL_OES_texture_stencil8
13348
13349 // GL_OES_texture_storage_multisample_2d_array
GL_TexStorage3DMultisampleOES(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)13350 void GL_APIENTRY GL_TexStorage3DMultisampleOES(GLenum target,
13351 GLsizei samples,
13352 GLenum internalformat,
13353 GLsizei width,
13354 GLsizei height,
13355 GLsizei depth,
13356 GLboolean fixedsamplelocations)
13357 {
13358 Context *context = GetValidGlobalContext();
13359 EVENT(context, GLTexStorage3DMultisampleOES,
13360 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, "
13361 "depth = %d, fixedsamplelocations = %s",
13362 CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples,
13363 GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height, depth,
13364 GLbooleanToString(fixedsamplelocations));
13365
13366 if (context)
13367 {
13368 TextureType targetPacked = PackParam<TextureType>(target);
13369 SCOPED_SHARE_CONTEXT_LOCK(context);
13370 bool isCallValid =
13371 (context->skipValidation() ||
13372 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
13373 context->getMutableErrorSetForValidation(),
13374 angle::EntryPoint::GLTexStorage3DMultisampleOES) &&
13375 ValidateTexStorage3DMultisampleOES(
13376 context, angle::EntryPoint::GLTexStorage3DMultisampleOES, targetPacked, samples,
13377 internalformat, width, height, depth, fixedsamplelocations)));
13378 if (isCallValid)
13379 {
13380 context->texStorage3DMultisample(targetPacked, samples, internalformat, width, height,
13381 depth, fixedsamplelocations);
13382 }
13383 ANGLE_CAPTURE_GL(TexStorage3DMultisampleOES, isCallValid, context, targetPacked, samples,
13384 internalformat, width, height, depth, fixedsamplelocations);
13385 }
13386 else
13387 {
13388 GenerateContextLostErrorOnCurrentGlobalContext();
13389 }
13390 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13391 }
13392
13393 // GL_OES_vertex_array_object
GL_BindVertexArrayOES(GLuint array)13394 void GL_APIENTRY GL_BindVertexArrayOES(GLuint array)
13395 {
13396 Context *context = GetValidGlobalContext();
13397 EVENT(context, GLBindVertexArrayOES, "context = %d, array = %u", CID(context), array);
13398
13399 if (context)
13400 {
13401 VertexArrayID arrayPacked = PackParam<VertexArrayID>(array);
13402 SCOPED_SHARE_CONTEXT_LOCK(context);
13403 bool isCallValid =
13404 (context->skipValidation() ||
13405 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
13406 context->getMutableErrorSetForValidation(),
13407 angle::EntryPoint::GLBindVertexArrayOES) &&
13408 ValidateBindVertexArrayOES(context, angle::EntryPoint::GLBindVertexArrayOES,
13409 arrayPacked)));
13410 if (isCallValid)
13411 {
13412 context->bindVertexArray(arrayPacked);
13413 }
13414 ANGLE_CAPTURE_GL(BindVertexArrayOES, isCallValid, context, arrayPacked);
13415 }
13416 else
13417 {
13418 GenerateContextLostErrorOnCurrentGlobalContext();
13419 }
13420 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13421 }
13422
GL_DeleteVertexArraysOES(GLsizei n,const GLuint * arrays)13423 void GL_APIENTRY GL_DeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
13424 {
13425 Context *context = GetValidGlobalContext();
13426 EVENT(context, GLDeleteVertexArraysOES, "context = %d, n = %d, arrays = 0x%016" PRIxPTR "",
13427 CID(context), n, (uintptr_t)arrays);
13428
13429 if (context)
13430 {
13431 const VertexArrayID *arraysPacked = PackParam<const VertexArrayID *>(arrays);
13432 SCOPED_SHARE_CONTEXT_LOCK(context);
13433 bool isCallValid =
13434 (context->skipValidation() ||
13435 ValidateDeleteVertexArraysOES(context, angle::EntryPoint::GLDeleteVertexArraysOES, n,
13436 arraysPacked));
13437 if (isCallValid)
13438 {
13439 context->deleteVertexArrays(n, arraysPacked);
13440 }
13441 ANGLE_CAPTURE_GL(DeleteVertexArraysOES, isCallValid, context, n, arraysPacked);
13442 }
13443 else
13444 {
13445 GenerateContextLostErrorOnCurrentGlobalContext();
13446 }
13447 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13448 }
13449
GL_GenVertexArraysOES(GLsizei n,GLuint * arrays)13450 void GL_APIENTRY GL_GenVertexArraysOES(GLsizei n, GLuint *arrays)
13451 {
13452 Context *context = GetValidGlobalContext();
13453 EVENT(context, GLGenVertexArraysOES, "context = %d, n = %d, arrays = 0x%016" PRIxPTR "",
13454 CID(context), n, (uintptr_t)arrays);
13455
13456 if (context)
13457 {
13458 VertexArrayID *arraysPacked = PackParam<VertexArrayID *>(arrays);
13459 SCOPED_SHARE_CONTEXT_LOCK(context);
13460 bool isCallValid = (context->skipValidation() ||
13461 ValidateGenVertexArraysOES(
13462 context, angle::EntryPoint::GLGenVertexArraysOES, n, arraysPacked));
13463 if (isCallValid)
13464 {
13465 context->genVertexArrays(n, arraysPacked);
13466 }
13467 ANGLE_CAPTURE_GL(GenVertexArraysOES, isCallValid, context, n, arraysPacked);
13468 }
13469 else
13470 {
13471 GenerateContextLostErrorOnCurrentGlobalContext();
13472 }
13473 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13474 }
13475
GL_IsVertexArrayOES(GLuint array)13476 GLboolean GL_APIENTRY GL_IsVertexArrayOES(GLuint array)
13477 {
13478 Context *context = GetValidGlobalContext();
13479 EVENT(context, GLIsVertexArrayOES, "context = %d, array = %u", CID(context), array);
13480
13481 GLboolean returnValue;
13482 if (context)
13483 {
13484 VertexArrayID arrayPacked = PackParam<VertexArrayID>(array);
13485 SCOPED_SHARE_CONTEXT_LOCK(context);
13486 bool isCallValid =
13487 (context->skipValidation() ||
13488 ValidateIsVertexArrayOES(context, angle::EntryPoint::GLIsVertexArrayOES, arrayPacked));
13489 if (isCallValid)
13490 {
13491 returnValue = context->isVertexArray(arrayPacked);
13492 }
13493 else
13494 {
13495 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsVertexArrayOES, GLboolean>();
13496 }
13497 ANGLE_CAPTURE_GL(IsVertexArrayOES, isCallValid, context, arrayPacked, returnValue);
13498 }
13499 else
13500 {
13501 GenerateContextLostErrorOnCurrentGlobalContext();
13502 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsVertexArrayOES, GLboolean>();
13503 }
13504 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13505 return returnValue;
13506 }
13507
13508 // GL_OES_vertex_half_float
13509
13510 // GL_OES_vertex_type_10_10_10_2
13511
13512 // GL_OVR_multiview
GL_FramebufferTextureMultiviewOVR(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint baseViewIndex,GLsizei numViews)13513 void GL_APIENTRY GL_FramebufferTextureMultiviewOVR(GLenum target,
13514 GLenum attachment,
13515 GLuint texture,
13516 GLint level,
13517 GLint baseViewIndex,
13518 GLsizei numViews)
13519 {
13520 Context *context = GetValidGlobalContext();
13521 EVENT(context, GLFramebufferTextureMultiviewOVR,
13522 "context = %d, target = %s, attachment = %s, texture = %u, level = %d, baseViewIndex = "
13523 "%d, numViews = %d",
13524 CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
13525 GLenumToString(GLESEnum::FramebufferAttachment, attachment), texture, level,
13526 baseViewIndex, numViews);
13527
13528 if (context)
13529 {
13530 TextureID texturePacked = PackParam<TextureID>(texture);
13531 SCOPED_SHARE_CONTEXT_LOCK(context);
13532 bool isCallValid =
13533 (context->skipValidation() ||
13534 (ValidatePixelLocalStorageInactive(
13535 context->getPrivateState(), context->getMutableErrorSetForValidation(),
13536 angle::EntryPoint::GLFramebufferTextureMultiviewOVR) &&
13537 ValidateFramebufferTextureMultiviewOVR(
13538 context, angle::EntryPoint::GLFramebufferTextureMultiviewOVR, target, attachment,
13539 texturePacked, level, baseViewIndex, numViews)));
13540 if (isCallValid)
13541 {
13542 context->framebufferTextureMultiview(target, attachment, texturePacked, level,
13543 baseViewIndex, numViews);
13544 }
13545 ANGLE_CAPTURE_GL(FramebufferTextureMultiviewOVR, isCallValid, context, target, attachment,
13546 texturePacked, level, baseViewIndex, numViews);
13547 }
13548 else
13549 {
13550 GenerateContextLostErrorOnCurrentGlobalContext();
13551 }
13552 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13553 }
13554
13555 // GL_OVR_multiview2
13556
13557 // GL_QCOM_framebuffer_foveated
GL_FramebufferFoveationConfigQCOM(GLuint framebuffer,GLuint numLayers,GLuint focalPointsPerLayer,GLuint requestedFeatures,GLuint * providedFeatures)13558 void GL_APIENTRY GL_FramebufferFoveationConfigQCOM(GLuint framebuffer,
13559 GLuint numLayers,
13560 GLuint focalPointsPerLayer,
13561 GLuint requestedFeatures,
13562 GLuint *providedFeatures)
13563 {
13564 Context *context = GetValidGlobalContext();
13565 EVENT(context, GLFramebufferFoveationConfigQCOM,
13566 "context = %d, framebuffer = %u, numLayers = %u, focalPointsPerLayer = %u, "
13567 "requestedFeatures = %u, providedFeatures = 0x%016" PRIxPTR "",
13568 CID(context), framebuffer, numLayers, focalPointsPerLayer, requestedFeatures,
13569 (uintptr_t)providedFeatures);
13570
13571 if (context)
13572 {
13573 FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
13574 SCOPED_SHARE_CONTEXT_LOCK(context);
13575 bool isCallValid =
13576 (context->skipValidation() ||
13577 (ValidatePixelLocalStorageInactive(
13578 context->getPrivateState(), context->getMutableErrorSetForValidation(),
13579 angle::EntryPoint::GLFramebufferFoveationConfigQCOM) &&
13580 ValidateFramebufferFoveationConfigQCOM(
13581 context, angle::EntryPoint::GLFramebufferFoveationConfigQCOM, framebufferPacked,
13582 numLayers, focalPointsPerLayer, requestedFeatures, providedFeatures)));
13583 if (isCallValid)
13584 {
13585 context->framebufferFoveationConfig(framebufferPacked, numLayers, focalPointsPerLayer,
13586 requestedFeatures, providedFeatures);
13587 }
13588 ANGLE_CAPTURE_GL(FramebufferFoveationConfigQCOM, isCallValid, context, framebufferPacked,
13589 numLayers, focalPointsPerLayer, requestedFeatures, providedFeatures);
13590 }
13591 else
13592 {
13593 GenerateContextLostErrorOnCurrentGlobalContext();
13594 }
13595 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13596 }
13597
GL_FramebufferFoveationParametersQCOM(GLuint framebuffer,GLuint layer,GLuint focalPoint,GLfloat focalX,GLfloat focalY,GLfloat gainX,GLfloat gainY,GLfloat foveaArea)13598 void GL_APIENTRY GL_FramebufferFoveationParametersQCOM(GLuint framebuffer,
13599 GLuint layer,
13600 GLuint focalPoint,
13601 GLfloat focalX,
13602 GLfloat focalY,
13603 GLfloat gainX,
13604 GLfloat gainY,
13605 GLfloat foveaArea)
13606 {
13607 Context *context = GetValidGlobalContext();
13608 EVENT(context, GLFramebufferFoveationParametersQCOM,
13609 "context = %d, framebuffer = %u, layer = %u, focalPoint = %u, focalX = %f, focalY = %f, "
13610 "gainX = %f, gainY = %f, foveaArea = %f",
13611 CID(context), framebuffer, layer, focalPoint, focalX, focalY, gainX, gainY, foveaArea);
13612
13613 if (context)
13614 {
13615 FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
13616 SCOPED_SHARE_CONTEXT_LOCK(context);
13617 bool isCallValid =
13618 (context->skipValidation() ||
13619 (ValidatePixelLocalStorageInactive(
13620 context->getPrivateState(), context->getMutableErrorSetForValidation(),
13621 angle::EntryPoint::GLFramebufferFoveationParametersQCOM) &&
13622 ValidateFramebufferFoveationParametersQCOM(
13623 context, angle::EntryPoint::GLFramebufferFoveationParametersQCOM,
13624 framebufferPacked, layer, focalPoint, focalX, focalY, gainX, gainY, foveaArea)));
13625 if (isCallValid)
13626 {
13627 context->framebufferFoveationParameters(framebufferPacked, layer, focalPoint, focalX,
13628 focalY, gainX, gainY, foveaArea);
13629 }
13630 ANGLE_CAPTURE_GL(FramebufferFoveationParametersQCOM, isCallValid, context,
13631 framebufferPacked, layer, focalPoint, focalX, focalY, gainX, gainY,
13632 foveaArea);
13633 }
13634 else
13635 {
13636 GenerateContextLostErrorOnCurrentGlobalContext();
13637 }
13638 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13639 }
13640
13641 // GL_QCOM_render_shared_exponent
13642
13643 // GL_QCOM_shading_rate
GL_ShadingRateQCOM(GLenum rate)13644 void GL_APIENTRY GL_ShadingRateQCOM(GLenum rate)
13645 {
13646 Context *context = GetValidGlobalContext();
13647 EVENT(context, GLShadingRateQCOM, "context = %d, rate = %s", CID(context),
13648 GLenumToString(GLESEnum::ShadingRateQCOM, rate));
13649
13650 if (context)
13651 {
13652 bool isCallValid =
13653 (context->skipValidation() ||
13654 (ValidatePixelLocalStorageInactive(context->getPrivateState(),
13655 context->getMutableErrorSetForValidation(),
13656 angle::EntryPoint::GLShadingRateQCOM) &&
13657 ValidateShadingRateQCOM(context->getPrivateState(),
13658 context->getMutableErrorSetForValidation(),
13659 angle::EntryPoint::GLShadingRateQCOM, rate)));
13660 if (isCallValid)
13661 {
13662 ContextPrivateShadingRate(context->getMutablePrivateState(),
13663 context->getMutablePrivateStateCache(), rate);
13664 }
13665 ANGLE_CAPTURE_GL(ShadingRateQCOM, isCallValid, context, rate);
13666 }
13667 else
13668 {
13669 GenerateContextLostErrorOnCurrentGlobalContext();
13670 }
13671 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13672 }
13673
13674 // GL_QCOM_texture_foveated
GL_TextureFoveationParametersQCOM(GLuint texture,GLuint layer,GLuint focalPoint,GLfloat focalX,GLfloat focalY,GLfloat gainX,GLfloat gainY,GLfloat foveaArea)13675 void GL_APIENTRY GL_TextureFoveationParametersQCOM(GLuint texture,
13676 GLuint layer,
13677 GLuint focalPoint,
13678 GLfloat focalX,
13679 GLfloat focalY,
13680 GLfloat gainX,
13681 GLfloat gainY,
13682 GLfloat foveaArea)
13683 {
13684 Context *context = GetValidGlobalContext();
13685 EVENT(context, GLTextureFoveationParametersQCOM,
13686 "context = %d, texture = %u, layer = %u, focalPoint = %u, focalX = %f, focalY = %f, "
13687 "gainX = %f, gainY = %f, foveaArea = %f",
13688 CID(context), texture, layer, focalPoint, focalX, focalY, gainX, gainY, foveaArea);
13689
13690 if (context)
13691 {
13692 TextureID texturePacked = PackParam<TextureID>(texture);
13693 SCOPED_SHARE_CONTEXT_LOCK(context);
13694 bool isCallValid =
13695 (context->skipValidation() ||
13696 (ValidatePixelLocalStorageInactive(
13697 context->getPrivateState(), context->getMutableErrorSetForValidation(),
13698 angle::EntryPoint::GLTextureFoveationParametersQCOM) &&
13699 ValidateTextureFoveationParametersQCOM(
13700 context, angle::EntryPoint::GLTextureFoveationParametersQCOM, texturePacked,
13701 layer, focalPoint, focalX, focalY, gainX, gainY, foveaArea)));
13702 if (isCallValid)
13703 {
13704 context->textureFoveationParameters(texturePacked, layer, focalPoint, focalX, focalY,
13705 gainX, gainY, foveaArea);
13706 }
13707 ANGLE_CAPTURE_GL(TextureFoveationParametersQCOM, isCallValid, context, texturePacked, layer,
13708 focalPoint, focalX, focalY, gainX, gainY, foveaArea);
13709 }
13710 else
13711 {
13712 GenerateContextLostErrorOnCurrentGlobalContext();
13713 }
13714 ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
13715 }
13716
13717 } // extern "C"
13718