• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml.
3 //
4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // entry_points_gles_3_2_autogen.cpp:
9 //   Defines the GLES 3.2 entry points.
10 
11 #include "libGLESv2/entry_points_gles_3_2_autogen.h"
12 
13 #include "libANGLE/Context.h"
14 #include "libANGLE/Context.inl.h"
15 #include "libANGLE/capture_gles_3_2_autogen.h"
16 #include "libANGLE/entry_points_utils.h"
17 #include "libANGLE/gl_enum_utils.h"
18 #include "libANGLE/validationES32.h"
19 #include "libGLESv2/global_state.h"
20 
21 namespace gl
22 {
BlendBarrier()23 void GL_APIENTRY BlendBarrier()
24 {
25     Context *context = GetValidGlobalContext();
26     EVENT("glBlendBarrier", "context = %d", CID(context));
27 
28     if (context)
29     {
30         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
31         bool isCallValid = (context->skipValidation() || ValidateBlendBarrier(context));
32         if (isCallValid)
33         {
34             context->blendBarrier();
35         }
36         ANGLE_CAPTURE(BlendBarrier, isCallValid, context);
37     }
38 }
39 
BlendEquationSeparatei(GLuint buf,GLenum modeRGB,GLenum modeAlpha)40 void GL_APIENTRY BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
41 {
42     Context *context = GetValidGlobalContext();
43     EVENT("glBlendEquationSeparatei",
44           "context = %d, GLuint buf = %u, GLenum modeRGB = %s, GLenum modeAlpha = %s", CID(context),
45           buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
46           GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
47 
48     if (context)
49     {
50         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
51         bool isCallValid                                      = (context->skipValidation() ||
52                             ValidateBlendEquationSeparatei(context, buf, modeRGB, modeAlpha));
53         if (isCallValid)
54         {
55             context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
56         }
57         ANGLE_CAPTURE(BlendEquationSeparatei, isCallValid, context, buf, modeRGB, modeAlpha);
58     }
59 }
60 
BlendEquationi(GLuint buf,GLenum mode)61 void GL_APIENTRY BlendEquationi(GLuint buf, GLenum mode)
62 {
63     Context *context = GetValidGlobalContext();
64     EVENT("glBlendEquationi", "context = %d, GLuint buf = %u, GLenum mode = %s", CID(context), buf,
65           GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
66 
67     if (context)
68     {
69         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
70         bool isCallValid =
71             (context->skipValidation() || ValidateBlendEquationi(context, buf, mode));
72         if (isCallValid)
73         {
74             context->blendEquationi(buf, mode);
75         }
76         ANGLE_CAPTURE(BlendEquationi, isCallValid, context, buf, mode);
77     }
78 }
79 
80 void GL_APIENTRY
BlendFuncSeparatei(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)81 BlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
82 {
83     Context *context = GetValidGlobalContext();
84     EVENT("glBlendFuncSeparatei",
85           "context = %d, GLuint buf = %u, GLenum srcRGB = %s, GLenum dstRGB = %s, GLenum srcAlpha "
86           "= %s, GLenum dstAlpha = %s",
87           CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
88           GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
89           GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
90           GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
91 
92     if (context)
93     {
94         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
95         bool isCallValid =
96             (context->skipValidation() ||
97              ValidateBlendFuncSeparatei(context, buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
98         if (isCallValid)
99         {
100             context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
101         }
102         ANGLE_CAPTURE(BlendFuncSeparatei, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
103                       dstAlpha);
104     }
105 }
106 
BlendFunci(GLuint buf,GLenum src,GLenum dst)107 void GL_APIENTRY BlendFunci(GLuint buf, GLenum src, GLenum dst)
108 {
109     Context *context = GetValidGlobalContext();
110     EVENT("glBlendFunci", "context = %d, GLuint buf = %u, GLenum src = %s, GLenum dst = %s",
111           CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, src),
112           GLenumToString(GLenumGroup::BlendingFactor, dst));
113 
114     if (context)
115     {
116         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
117         bool isCallValid =
118             (context->skipValidation() || ValidateBlendFunci(context, buf, src, dst));
119         if (isCallValid)
120         {
121             context->blendFunci(buf, src, dst);
122         }
123         ANGLE_CAPTURE(BlendFunci, isCallValid, context, buf, src, dst);
124     }
125 }
126 
ColorMaski(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)127 void GL_APIENTRY ColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
128 {
129     Context *context = GetValidGlobalContext();
130     EVENT("glColorMaski",
131           "context = %d, GLuint index = %u, GLboolean r = %s, GLboolean g = %s, GLboolean b = %s, "
132           "GLboolean a = %s",
133           CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b),
134           GLbooleanToString(a));
135 
136     if (context)
137     {
138         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
139         bool isCallValid =
140             (context->skipValidation() || ValidateColorMaski(context, index, r, g, b, a));
141         if (isCallValid)
142         {
143             context->colorMaski(index, r, g, b, a);
144         }
145         ANGLE_CAPTURE(ColorMaski, isCallValid, context, index, r, g, b, a);
146     }
147 }
148 
CopyImageSubData(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)149 void GL_APIENTRY CopyImageSubData(GLuint srcName,
150                                   GLenum srcTarget,
151                                   GLint srcLevel,
152                                   GLint srcX,
153                                   GLint srcY,
154                                   GLint srcZ,
155                                   GLuint dstName,
156                                   GLenum dstTarget,
157                                   GLint dstLevel,
158                                   GLint dstX,
159                                   GLint dstY,
160                                   GLint dstZ,
161                                   GLsizei srcWidth,
162                                   GLsizei srcHeight,
163                                   GLsizei srcDepth)
164 {
165     Context *context = GetValidGlobalContext();
166     EVENT("glCopyImageSubData",
167           "context = %d, GLuint srcName = %u, GLenum srcTarget = %s, GLint srcLevel = %d, GLint "
168           "srcX = %d, GLint srcY = %d, GLint srcZ = %d, GLuint dstName = %u, GLenum dstTarget = "
169           "%s, GLint dstLevel = %d, GLint dstX = %d, GLint dstY = %d, GLint dstZ = %d, GLsizei "
170           "srcWidth = %d, GLsizei srcHeight = %d, GLsizei srcDepth = %d",
171           CID(context), srcName, GLenumToString(GLenumGroup::CopyBufferSubDataTarget, srcTarget),
172           srcLevel, srcX, srcY, srcZ, dstName,
173           GLenumToString(GLenumGroup::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY,
174           dstZ, srcWidth, srcHeight, srcDepth);
175 
176     if (context)
177     {
178         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
179         bool isCallValid                                      = (context->skipValidation() ||
180                             ValidateCopyImageSubData(context, srcName, srcTarget, srcLevel, srcX,
181                                                      srcY, srcZ, dstName, dstTarget, dstLevel, dstX,
182                                                      dstY, dstZ, srcWidth, srcHeight, srcDepth));
183         if (isCallValid)
184         {
185             context->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
186                                       dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
187                                       srcDepth);
188         }
189         ANGLE_CAPTURE(CopyImageSubData, isCallValid, context, srcName, srcTarget, srcLevel, srcX,
190                       srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
191                       srcHeight, srcDepth);
192     }
193 }
194 
DebugMessageCallback(GLDEBUGPROC callback,const void * userParam)195 void GL_APIENTRY DebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
196 {
197     Context *context = GetValidGlobalContext();
198     EVENT("glDebugMessageCallback",
199           "context = %d, GLDEBUGPROC callback = 0x%016" PRIxPTR
200           ", const void *userParam = 0x%016" PRIxPTR "",
201           CID(context), (uintptr_t)callback, (uintptr_t)userParam);
202 
203     if (context)
204     {
205         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
206         bool isCallValid                                      = (context->skipValidation() ||
207                             ValidateDebugMessageCallback(context, callback, userParam));
208         if (isCallValid)
209         {
210             context->debugMessageCallback(callback, userParam);
211         }
212         ANGLE_CAPTURE(DebugMessageCallback, isCallValid, context, callback, userParam);
213     }
214 }
215 
DebugMessageControl(GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint * ids,GLboolean enabled)216 void GL_APIENTRY DebugMessageControl(GLenum source,
217                                      GLenum type,
218                                      GLenum severity,
219                                      GLsizei count,
220                                      const GLuint *ids,
221                                      GLboolean enabled)
222 {
223     Context *context = GetValidGlobalContext();
224     EVENT("glDebugMessageControl",
225           "context = %d, GLenum source = %s, GLenum type = %s, GLenum severity = %s, GLsizei count "
226           "= %d, const GLuint *ids = 0x%016" PRIxPTR ", GLboolean enabled = %s",
227           CID(context), GLenumToString(GLenumGroup::DebugSource, source),
228           GLenumToString(GLenumGroup::DebugType, type),
229           GLenumToString(GLenumGroup::DebugSeverity, severity), count, (uintptr_t)ids,
230           GLbooleanToString(enabled));
231 
232     if (context)
233     {
234         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
235         bool isCallValid =
236             (context->skipValidation() ||
237              ValidateDebugMessageControl(context, source, type, severity, count, ids, enabled));
238         if (isCallValid)
239         {
240             context->debugMessageControl(source, type, severity, count, ids, enabled);
241         }
242         ANGLE_CAPTURE(DebugMessageControl, isCallValid, context, source, type, severity, count, ids,
243                       enabled);
244     }
245 }
246 
DebugMessageInsert(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar * buf)247 void GL_APIENTRY DebugMessageInsert(GLenum source,
248                                     GLenum type,
249                                     GLuint id,
250                                     GLenum severity,
251                                     GLsizei length,
252                                     const GLchar *buf)
253 {
254     Context *context = GetValidGlobalContext();
255     EVENT("glDebugMessageInsert",
256           "context = %d, GLenum source = %s, GLenum type = %s, GLuint id = %u, GLenum severity = "
257           "%s, GLsizei length = %d, const GLchar *buf = 0x%016" PRIxPTR "",
258           CID(context), GLenumToString(GLenumGroup::DebugSource, source),
259           GLenumToString(GLenumGroup::DebugType, type), id,
260           GLenumToString(GLenumGroup::DebugSeverity, severity), length, (uintptr_t)buf);
261 
262     if (context)
263     {
264         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
265         bool isCallValid =
266             (context->skipValidation() ||
267              ValidateDebugMessageInsert(context, source, type, id, severity, length, buf));
268         if (isCallValid)
269         {
270             context->debugMessageInsert(source, type, id, severity, length, buf);
271         }
272         ANGLE_CAPTURE(DebugMessageInsert, isCallValid, context, source, type, id, severity, length,
273                       buf);
274     }
275 }
276 
Disablei(GLenum target,GLuint index)277 void GL_APIENTRY Disablei(GLenum target, GLuint index)
278 {
279     Context *context = GetValidGlobalContext();
280     EVENT("glDisablei", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
281           GLenumToString(GLenumGroup::EnableCap, target), index);
282 
283     if (context)
284     {
285         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
286         bool isCallValid = (context->skipValidation() || ValidateDisablei(context, target, index));
287         if (isCallValid)
288         {
289             context->disablei(target, index);
290         }
291         ANGLE_CAPTURE(Disablei, isCallValid, context, target, index);
292     }
293 }
294 
DrawElementsBaseVertex(GLenum mode,GLsizei count,GLenum type,const void * indices,GLint basevertex)295 void GL_APIENTRY DrawElementsBaseVertex(GLenum mode,
296                                         GLsizei count,
297                                         GLenum type,
298                                         const void *indices,
299                                         GLint basevertex)
300 {
301     Context *context = GetValidGlobalContext();
302     EVENT("glDrawElementsBaseVertex",
303           "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
304           "*indices = 0x%016" PRIxPTR ", GLint basevertex = %d",
305           CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
306           GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
307 
308     if (context)
309     {
310         PrimitiveMode modePacked                              = FromGL<PrimitiveMode>(mode);
311         DrawElementsType typePacked                           = FromGL<DrawElementsType>(type);
312         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
313         bool isCallValid                                      = (context->skipValidation() ||
314                             ValidateDrawElementsBaseVertex(context, modePacked, count, typePacked,
315                                                            indices, basevertex));
316         if (isCallValid)
317         {
318             context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex);
319         }
320         ANGLE_CAPTURE(DrawElementsBaseVertex, isCallValid, context, modePacked, count, typePacked,
321                       indices, basevertex);
322     }
323 }
324 
DrawElementsInstancedBaseVertex(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei instancecount,GLint basevertex)325 void GL_APIENTRY DrawElementsInstancedBaseVertex(GLenum mode,
326                                                  GLsizei count,
327                                                  GLenum type,
328                                                  const void *indices,
329                                                  GLsizei instancecount,
330                                                  GLint basevertex)
331 {
332     Context *context = GetValidGlobalContext();
333     EVENT("glDrawElementsInstancedBaseVertex",
334           "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void "
335           "*indices = 0x%016" PRIxPTR ", GLsizei instancecount = %d, GLint basevertex = %d",
336           CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count,
337           GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount,
338           basevertex);
339 
340     if (context)
341     {
342         PrimitiveMode modePacked                              = FromGL<PrimitiveMode>(mode);
343         DrawElementsType typePacked                           = FromGL<DrawElementsType>(type);
344         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
345         bool isCallValid = (context->skipValidation() || ValidateDrawElementsInstancedBaseVertex(
346                                                              context, modePacked, count, typePacked,
347                                                              indices, instancecount, basevertex));
348         if (isCallValid)
349         {
350             context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices,
351                                                      instancecount, basevertex);
352         }
353         ANGLE_CAPTURE(DrawElementsInstancedBaseVertex, isCallValid, context, modePacked, count,
354                       typePacked, indices, instancecount, basevertex);
355     }
356 }
357 
DrawRangeElementsBaseVertex(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices,GLint basevertex)358 void GL_APIENTRY DrawRangeElementsBaseVertex(GLenum mode,
359                                              GLuint start,
360                                              GLuint end,
361                                              GLsizei count,
362                                              GLenum type,
363                                              const void *indices,
364                                              GLint basevertex)
365 {
366     Context *context = GetValidGlobalContext();
367     EVENT("glDrawRangeElementsBaseVertex",
368           "context = %d, GLenum mode = %s, GLuint start = %u, GLuint end = %u, GLsizei count = %d, "
369           "GLenum type = %s, const void *indices = 0x%016" PRIxPTR ", GLint basevertex = %d",
370           CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
371           GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex);
372 
373     if (context)
374     {
375         PrimitiveMode modePacked                              = FromGL<PrimitiveMode>(mode);
376         DrawElementsType typePacked                           = FromGL<DrawElementsType>(type);
377         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
378         bool isCallValid = (context->skipValidation() || ValidateDrawRangeElementsBaseVertex(
379                                                              context, modePacked, start, end, count,
380                                                              typePacked, indices, basevertex));
381         if (isCallValid)
382         {
383             context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices,
384                                                  basevertex);
385         }
386         ANGLE_CAPTURE(DrawRangeElementsBaseVertex, isCallValid, context, modePacked, start, end,
387                       count, typePacked, indices, basevertex);
388     }
389 }
390 
Enablei(GLenum target,GLuint index)391 void GL_APIENTRY Enablei(GLenum target, GLuint index)
392 {
393     Context *context = GetValidGlobalContext();
394     EVENT("glEnablei", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
395           GLenumToString(GLenumGroup::EnableCap, target), index);
396 
397     if (context)
398     {
399         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
400         bool isCallValid = (context->skipValidation() || ValidateEnablei(context, target, index));
401         if (isCallValid)
402         {
403             context->enablei(target, index);
404         }
405         ANGLE_CAPTURE(Enablei, isCallValid, context, target, index);
406     }
407 }
408 
FramebufferTexture(GLenum target,GLenum attachment,GLuint texture,GLint level)409 void GL_APIENTRY FramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
410 {
411     Context *context = GetValidGlobalContext();
412     EVENT("glFramebufferTexture",
413           "context = %d, GLenum target = %s, GLenum attachment = %s, GLuint texture = %u, GLint "
414           "level = %d",
415           CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
416           GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level);
417 
418     if (context)
419     {
420         TextureID texturePacked                               = FromGL<TextureID>(texture);
421         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
422         bool isCallValid =
423             (context->skipValidation() ||
424              ValidateFramebufferTexture(context, target, attachment, texturePacked, level));
425         if (isCallValid)
426         {
427             context->framebufferTexture(target, attachment, texturePacked, level);
428         }
429         ANGLE_CAPTURE(FramebufferTexture, isCallValid, context, target, attachment, texturePacked,
430                       level);
431     }
432 }
433 
GetDebugMessageLog(GLuint count,GLsizei bufSize,GLenum * sources,GLenum * types,GLuint * ids,GLenum * severities,GLsizei * lengths,GLchar * messageLog)434 GLuint GL_APIENTRY GetDebugMessageLog(GLuint count,
435                                       GLsizei bufSize,
436                                       GLenum *sources,
437                                       GLenum *types,
438                                       GLuint *ids,
439                                       GLenum *severities,
440                                       GLsizei *lengths,
441                                       GLchar *messageLog)
442 {
443     Context *context = GetValidGlobalContext();
444     EVENT("glGetDebugMessageLog",
445           "context = %d, GLuint count = %u, GLsizei bufSize = %d, GLenum *sources = 0x%016" PRIxPTR
446           ", GLenum *types = 0x%016" PRIxPTR ", GLuint *ids = 0x%016" PRIxPTR
447           ", GLenum *severities = 0x%016" PRIxPTR ", GLsizei *lengths = 0x%016" PRIxPTR
448           ", GLchar *messageLog = 0x%016" PRIxPTR "",
449           CID(context), count, bufSize, (uintptr_t)sources, (uintptr_t)types, (uintptr_t)ids,
450           (uintptr_t)severities, (uintptr_t)lengths, (uintptr_t)messageLog);
451 
452     GLuint returnValue;
453     if (context)
454     {
455         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
456         bool isCallValid                                      = (context->skipValidation() ||
457                             ValidateGetDebugMessageLog(context, count, bufSize, sources, types, ids,
458                                                        severities, lengths, messageLog));
459         if (isCallValid)
460         {
461             returnValue = context->getDebugMessageLog(count, bufSize, sources, types, ids,
462                                                       severities, lengths, messageLog);
463         }
464         else
465         {
466             returnValue = GetDefaultReturnValue<EntryPoint::GetDebugMessageLog, GLuint>();
467         }
468         ANGLE_CAPTURE(GetDebugMessageLog, isCallValid, context, count, bufSize, sources, types, ids,
469                       severities, lengths, messageLog, returnValue);
470     }
471     else
472     {
473         returnValue = GetDefaultReturnValue<EntryPoint::GetDebugMessageLog, GLuint>();
474     }
475     return returnValue;
476 }
477 
GetGraphicsResetStatus()478 GLenum GL_APIENTRY GetGraphicsResetStatus()
479 {
480     Context *context = GetGlobalContext();
481     EVENT("glGetGraphicsResetStatus", "context = %d", CID(context));
482 
483     GLenum returnValue;
484     if (context)
485     {
486         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
487         bool isCallValid = (context->skipValidation() || ValidateGetGraphicsResetStatus(context));
488         if (isCallValid)
489         {
490             returnValue = context->getGraphicsResetStatus();
491         }
492         else
493         {
494             returnValue = GetDefaultReturnValue<EntryPoint::GetGraphicsResetStatus, GLenum>();
495         }
496         ANGLE_CAPTURE(GetGraphicsResetStatus, isCallValid, context, returnValue);
497     }
498     else
499     {
500         returnValue = GetDefaultReturnValue<EntryPoint::GetGraphicsResetStatus, GLenum>();
501     }
502     return returnValue;
503 }
504 
505 void GL_APIENTRY
GetObjectLabel(GLenum identifier,GLuint name,GLsizei bufSize,GLsizei * length,GLchar * label)506 GetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
507 {
508     Context *context = GetValidGlobalContext();
509     EVENT("glGetObjectLabel",
510           "context = %d, GLenum identifier = %s, GLuint name = %u, GLsizei bufSize = %d, GLsizei "
511           "*length = 0x%016" PRIxPTR ", GLchar *label = 0x%016" PRIxPTR "",
512           CID(context), GLenumToString(GLenumGroup::DefaultGroup, identifier), name, bufSize,
513           (uintptr_t)length, (uintptr_t)label);
514 
515     if (context)
516     {
517         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
518         bool isCallValid =
519             (context->skipValidation() ||
520              ValidateGetObjectLabel(context, identifier, name, bufSize, length, label));
521         if (isCallValid)
522         {
523             context->getObjectLabel(identifier, name, bufSize, length, label);
524         }
525         ANGLE_CAPTURE(GetObjectLabel, isCallValid, context, identifier, name, bufSize, length,
526                       label);
527     }
528 }
529 
GetObjectPtrLabel(const void * ptr,GLsizei bufSize,GLsizei * length,GLchar * label)530 void GL_APIENTRY GetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
531 {
532     Context *context = GetValidGlobalContext();
533     EVENT("glGetObjectPtrLabel",
534           "context = %d, const void *ptr = 0x%016" PRIxPTR
535           ", GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
536           ", GLchar *label = 0x%016" PRIxPTR "",
537           CID(context), (uintptr_t)ptr, bufSize, (uintptr_t)length, (uintptr_t)label);
538 
539     if (context)
540     {
541         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
542         bool isCallValid                                      = (context->skipValidation() ||
543                             ValidateGetObjectPtrLabel(context, ptr, bufSize, length, label));
544         if (isCallValid)
545         {
546             context->getObjectPtrLabel(ptr, bufSize, length, label);
547         }
548         ANGLE_CAPTURE(GetObjectPtrLabel, isCallValid, context, ptr, bufSize, length, label);
549     }
550 }
551 
GetPointerv(GLenum pname,void ** params)552 void GL_APIENTRY GetPointerv(GLenum pname, void **params)
553 {
554     Context *context = GetValidGlobalContext();
555     EVENT("glGetPointerv", "context = %d, GLenum pname = %s, void **params = 0x%016" PRIxPTR "",
556           CID(context), GLenumToString(GLenumGroup::GetPointervPName, pname), (uintptr_t)params);
557 
558     if (context)
559     {
560         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
561         bool isCallValid =
562             (context->skipValidation() || ValidateGetPointerv(context, pname, params));
563         if (isCallValid)
564         {
565             context->getPointerv(pname, params);
566         }
567         ANGLE_CAPTURE(GetPointerv, isCallValid, context, pname, params);
568     }
569 }
570 
GetSamplerParameterIiv(GLuint sampler,GLenum pname,GLint * params)571 void GL_APIENTRY GetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
572 {
573     Context *context = GetValidGlobalContext();
574     EVENT("glGetSamplerParameterIiv",
575           "context = %d, GLuint sampler = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
576           CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
577           (uintptr_t)params);
578 
579     if (context)
580     {
581         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
582         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
583         bool isCallValid                                      = (context->skipValidation() ||
584                             ValidateGetSamplerParameterIiv(context, samplerPacked, pname, params));
585         if (isCallValid)
586         {
587             context->getSamplerParameterIiv(samplerPacked, pname, params);
588         }
589         ANGLE_CAPTURE(GetSamplerParameterIiv, isCallValid, context, samplerPacked, pname, params);
590     }
591 }
592 
GetSamplerParameterIuiv(GLuint sampler,GLenum pname,GLuint * params)593 void GL_APIENTRY GetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
594 {
595     Context *context = GetValidGlobalContext();
596     EVENT("glGetSamplerParameterIuiv",
597           "context = %d, GLuint sampler = %u, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR
598           "",
599           CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
600           (uintptr_t)params);
601 
602     if (context)
603     {
604         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
605         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
606         bool isCallValid                                      = (context->skipValidation() ||
607                             ValidateGetSamplerParameterIuiv(context, samplerPacked, pname, params));
608         if (isCallValid)
609         {
610             context->getSamplerParameterIuiv(samplerPacked, pname, params);
611         }
612         ANGLE_CAPTURE(GetSamplerParameterIuiv, isCallValid, context, samplerPacked, pname, params);
613     }
614 }
615 
GetTexParameterIiv(GLenum target,GLenum pname,GLint * params)616 void GL_APIENTRY GetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
617 {
618     Context *context = GetValidGlobalContext();
619     EVENT("glGetTexParameterIiv",
620           "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
621           CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
622           GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
623 
624     if (context)
625     {
626         TextureType targetPacked                              = FromGL<TextureType>(target);
627         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
628         bool isCallValid                                      = (context->skipValidation() ||
629                             ValidateGetTexParameterIiv(context, targetPacked, pname, params));
630         if (isCallValid)
631         {
632             context->getTexParameterIiv(targetPacked, pname, params);
633         }
634         ANGLE_CAPTURE(GetTexParameterIiv, isCallValid, context, targetPacked, pname, params);
635     }
636 }
637 
GetTexParameterIuiv(GLenum target,GLenum pname,GLuint * params)638 void GL_APIENTRY GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
639 {
640     Context *context = GetValidGlobalContext();
641     EVENT("glGetTexParameterIuiv",
642           "context = %d, GLenum target = %s, GLenum pname = %s, GLuint *params = 0x%016" PRIxPTR "",
643           CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
644           GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
645 
646     if (context)
647     {
648         TextureType targetPacked                              = FromGL<TextureType>(target);
649         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
650         bool isCallValid                                      = (context->skipValidation() ||
651                             ValidateGetTexParameterIuiv(context, targetPacked, pname, params));
652         if (isCallValid)
653         {
654             context->getTexParameterIuiv(targetPacked, pname, params);
655         }
656         ANGLE_CAPTURE(GetTexParameterIuiv, isCallValid, context, targetPacked, pname, params);
657     }
658 }
659 
GetnUniformfv(GLuint program,GLint location,GLsizei bufSize,GLfloat * params)660 void GL_APIENTRY GetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
661 {
662     Context *context = GetValidGlobalContext();
663     EVENT("glGetnUniformfv",
664           "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLfloat "
665           "*params = 0x%016" PRIxPTR "",
666           CID(context), program, location, bufSize, (uintptr_t)params);
667 
668     if (context)
669     {
670         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
671         UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
672         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
673         bool isCallValid =
674             (context->skipValidation() ||
675              ValidateGetnUniformfv(context, programPacked, locationPacked, bufSize, params));
676         if (isCallValid)
677         {
678             context->getnUniformfv(programPacked, locationPacked, bufSize, params);
679         }
680         ANGLE_CAPTURE(GetnUniformfv, isCallValid, context, programPacked, locationPacked, bufSize,
681                       params);
682     }
683 }
684 
GetnUniformiv(GLuint program,GLint location,GLsizei bufSize,GLint * params)685 void GL_APIENTRY GetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params)
686 {
687     Context *context = GetValidGlobalContext();
688     EVENT("glGetnUniformiv",
689           "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLint "
690           "*params = 0x%016" PRIxPTR "",
691           CID(context), program, location, bufSize, (uintptr_t)params);
692 
693     if (context)
694     {
695         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
696         UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
697         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
698         bool isCallValid =
699             (context->skipValidation() ||
700              ValidateGetnUniformiv(context, programPacked, locationPacked, bufSize, params));
701         if (isCallValid)
702         {
703             context->getnUniformiv(programPacked, locationPacked, bufSize, params);
704         }
705         ANGLE_CAPTURE(GetnUniformiv, isCallValid, context, programPacked, locationPacked, bufSize,
706                       params);
707     }
708 }
709 
GetnUniformuiv(GLuint program,GLint location,GLsizei bufSize,GLuint * params)710 void GL_APIENTRY GetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
711 {
712     Context *context = GetValidGlobalContext();
713     EVENT("glGetnUniformuiv",
714           "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLuint "
715           "*params = 0x%016" PRIxPTR "",
716           CID(context), program, location, bufSize, (uintptr_t)params);
717 
718     if (context)
719     {
720         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
721         UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
722         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
723         bool isCallValid =
724             (context->skipValidation() ||
725              ValidateGetnUniformuiv(context, programPacked, locationPacked, bufSize, params));
726         if (isCallValid)
727         {
728             context->getnUniformuiv(programPacked, locationPacked, bufSize, params);
729         }
730         ANGLE_CAPTURE(GetnUniformuiv, isCallValid, context, programPacked, locationPacked, bufSize,
731                       params);
732     }
733 }
734 
IsEnabledi(GLenum target,GLuint index)735 GLboolean GL_APIENTRY IsEnabledi(GLenum target, GLuint index)
736 {
737     Context *context = GetValidGlobalContext();
738     EVENT("glIsEnabledi", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
739           GLenumToString(GLenumGroup::EnableCap, target), index);
740 
741     GLboolean returnValue;
742     if (context)
743     {
744         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
745         bool isCallValid =
746             (context->skipValidation() || ValidateIsEnabledi(context, target, index));
747         if (isCallValid)
748         {
749             returnValue = context->isEnabledi(target, index);
750         }
751         else
752         {
753             returnValue = GetDefaultReturnValue<EntryPoint::IsEnabledi, GLboolean>();
754         }
755         ANGLE_CAPTURE(IsEnabledi, isCallValid, context, target, index, returnValue);
756     }
757     else
758     {
759         returnValue = GetDefaultReturnValue<EntryPoint::IsEnabledi, GLboolean>();
760     }
761     return returnValue;
762 }
763 
MinSampleShading(GLfloat value)764 void GL_APIENTRY MinSampleShading(GLfloat value)
765 {
766     Context *context = GetValidGlobalContext();
767     EVENT("glMinSampleShading", "context = %d, GLfloat value = %f", CID(context), value);
768 
769     if (context)
770     {
771         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
772         bool isCallValid = (context->skipValidation() || ValidateMinSampleShading(context, value));
773         if (isCallValid)
774         {
775             context->minSampleShading(value);
776         }
777         ANGLE_CAPTURE(MinSampleShading, isCallValid, context, value);
778     }
779 }
780 
ObjectLabel(GLenum identifier,GLuint name,GLsizei length,const GLchar * label)781 void GL_APIENTRY ObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
782 {
783     Context *context = GetValidGlobalContext();
784     EVENT("glObjectLabel",
785           "context = %d, GLenum identifier = %s, GLuint name = %u, GLsizei length = %d, const "
786           "GLchar *label = 0x%016" PRIxPTR "",
787           CID(context), GLenumToString(GLenumGroup::ObjectIdentifier, identifier), name, length,
788           (uintptr_t)label);
789 
790     if (context)
791     {
792         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
793         bool isCallValid                                      = (context->skipValidation() ||
794                             ValidateObjectLabel(context, identifier, name, length, label));
795         if (isCallValid)
796         {
797             context->objectLabel(identifier, name, length, label);
798         }
799         ANGLE_CAPTURE(ObjectLabel, isCallValid, context, identifier, name, length, label);
800     }
801 }
802 
ObjectPtrLabel(const void * ptr,GLsizei length,const GLchar * label)803 void GL_APIENTRY ObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
804 {
805     Context *context = GetValidGlobalContext();
806     EVENT("glObjectPtrLabel",
807           "context = %d, const void *ptr = 0x%016" PRIxPTR
808           ", GLsizei length = %d, const GLchar *label = 0x%016" PRIxPTR "",
809           CID(context), (uintptr_t)ptr, length, (uintptr_t)label);
810 
811     if (context)
812     {
813         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
814         bool isCallValid =
815             (context->skipValidation() || ValidateObjectPtrLabel(context, ptr, length, label));
816         if (isCallValid)
817         {
818             context->objectPtrLabel(ptr, length, label);
819         }
820         ANGLE_CAPTURE(ObjectPtrLabel, isCallValid, context, ptr, length, label);
821     }
822 }
823 
PatchParameteri(GLenum pname,GLint value)824 void GL_APIENTRY PatchParameteri(GLenum pname, GLint value)
825 {
826     Context *context = GetValidGlobalContext();
827     EVENT("glPatchParameteri", "context = %d, GLenum pname = %s, GLint value = %d", CID(context),
828           GLenumToString(GLenumGroup::PatchParameterName, pname), value);
829 
830     if (context)
831     {
832         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
833         bool isCallValid =
834             (context->skipValidation() || ValidatePatchParameteri(context, pname, value));
835         if (isCallValid)
836         {
837             context->patchParameteri(pname, value);
838         }
839         ANGLE_CAPTURE(PatchParameteri, isCallValid, context, pname, value);
840     }
841 }
842 
PopDebugGroup()843 void GL_APIENTRY PopDebugGroup()
844 {
845     Context *context = GetValidGlobalContext();
846     EVENT("glPopDebugGroup", "context = %d", CID(context));
847 
848     if (context)
849     {
850         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
851         bool isCallValid = (context->skipValidation() || ValidatePopDebugGroup(context));
852         if (isCallValid)
853         {
854             context->popDebugGroup();
855         }
856         ANGLE_CAPTURE(PopDebugGroup, isCallValid, context);
857     }
858 }
859 
PrimitiveBoundingBox(GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW)860 void GL_APIENTRY PrimitiveBoundingBox(GLfloat minX,
861                                       GLfloat minY,
862                                       GLfloat minZ,
863                                       GLfloat minW,
864                                       GLfloat maxX,
865                                       GLfloat maxY,
866                                       GLfloat maxZ,
867                                       GLfloat maxW)
868 {
869     Context *context = GetValidGlobalContext();
870     EVENT("glPrimitiveBoundingBox",
871           "context = %d, GLfloat minX = %f, GLfloat minY = %f, GLfloat minZ = %f, GLfloat minW = "
872           "%f, GLfloat maxX = %f, GLfloat maxY = %f, GLfloat maxZ = %f, GLfloat maxW = %f",
873           CID(context), minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
874 
875     if (context)
876     {
877         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
878         bool isCallValid =
879             (context->skipValidation() ||
880              ValidatePrimitiveBoundingBox(context, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW));
881         if (isCallValid)
882         {
883             context->primitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
884         }
885         ANGLE_CAPTURE(PrimitiveBoundingBox, isCallValid, context, minX, minY, minZ, minW, maxX,
886                       maxY, maxZ, maxW);
887     }
888 }
889 
PushDebugGroup(GLenum source,GLuint id,GLsizei length,const GLchar * message)890 void GL_APIENTRY PushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
891 {
892     Context *context = GetValidGlobalContext();
893     EVENT("glPushDebugGroup",
894           "context = %d, GLenum source = %s, GLuint id = %u, GLsizei length = %d, const GLchar "
895           "*message = 0x%016" PRIxPTR "",
896           CID(context), GLenumToString(GLenumGroup::DebugSource, source), id, length,
897           (uintptr_t)message);
898 
899     if (context)
900     {
901         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
902         bool isCallValid                                      = (context->skipValidation() ||
903                             ValidatePushDebugGroup(context, source, id, length, message));
904         if (isCallValid)
905         {
906             context->pushDebugGroup(source, id, length, message);
907         }
908         ANGLE_CAPTURE(PushDebugGroup, isCallValid, context, source, id, length, message);
909     }
910 }
911 
ReadnPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)912 void GL_APIENTRY ReadnPixels(GLint x,
913                              GLint y,
914                              GLsizei width,
915                              GLsizei height,
916                              GLenum format,
917                              GLenum type,
918                              GLsizei bufSize,
919                              void *data)
920 {
921     Context *context = GetValidGlobalContext();
922     EVENT("glReadnPixels",
923           "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
924           "GLenum format = %s, GLenum type = %s, GLsizei bufSize = %d, void *data = 0x%016" PRIxPTR
925           "",
926           CID(context), x, y, width, height, GLenumToString(GLenumGroup::PixelFormat, format),
927           GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)data);
928 
929     if (context)
930     {
931         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
932         bool isCallValid =
933             (context->skipValidation() ||
934              ValidateReadnPixels(context, x, y, width, height, format, type, bufSize, data));
935         if (isCallValid)
936         {
937             context->readnPixels(x, y, width, height, format, type, bufSize, data);
938         }
939         ANGLE_CAPTURE(ReadnPixels, isCallValid, context, x, y, width, height, format, type, bufSize,
940                       data);
941     }
942 }
943 
SamplerParameterIiv(GLuint sampler,GLenum pname,const GLint * param)944 void GL_APIENTRY SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
945 {
946     Context *context = GetValidGlobalContext();
947     EVENT(
948         "glSamplerParameterIiv",
949         "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLint *param = 0x%016" PRIxPTR
950         "",
951         CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
952         (uintptr_t)param);
953 
954     if (context)
955     {
956         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
957         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
958         bool isCallValid                                      = (context->skipValidation() ||
959                             ValidateSamplerParameterIiv(context, samplerPacked, pname, param));
960         if (isCallValid)
961         {
962             context->samplerParameterIiv(samplerPacked, pname, param);
963         }
964         ANGLE_CAPTURE(SamplerParameterIiv, isCallValid, context, samplerPacked, pname, param);
965     }
966 }
967 
SamplerParameterIuiv(GLuint sampler,GLenum pname,const GLuint * param)968 void GL_APIENTRY SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
969 {
970     Context *context = GetValidGlobalContext();
971     EVENT(
972         "glSamplerParameterIuiv",
973         "context = %d, GLuint sampler = %u, GLenum pname = %s, const GLuint *param = 0x%016" PRIxPTR
974         "",
975         CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname),
976         (uintptr_t)param);
977 
978     if (context)
979     {
980         SamplerID samplerPacked                               = FromGL<SamplerID>(sampler);
981         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
982         bool isCallValid                                      = (context->skipValidation() ||
983                             ValidateSamplerParameterIuiv(context, samplerPacked, pname, param));
984         if (isCallValid)
985         {
986             context->samplerParameterIuiv(samplerPacked, pname, param);
987         }
988         ANGLE_CAPTURE(SamplerParameterIuiv, isCallValid, context, samplerPacked, pname, param);
989     }
990 }
991 
TexBuffer(GLenum target,GLenum internalformat,GLuint buffer)992 void GL_APIENTRY TexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
993 {
994     Context *context = GetValidGlobalContext();
995     EVENT("glTexBuffer",
996           "context = %d, GLenum target = %s, GLenum internalformat = %s, GLuint buffer = %u",
997           CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
998           GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer);
999 
1000     if (context)
1001     {
1002         BufferID bufferPacked                                 = FromGL<BufferID>(buffer);
1003         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1004         bool isCallValid                                      = (context->skipValidation() ||
1005                             ValidateTexBuffer(context, target, internalformat, bufferPacked));
1006         if (isCallValid)
1007         {
1008             context->texBuffer(target, internalformat, bufferPacked);
1009         }
1010         ANGLE_CAPTURE(TexBuffer, isCallValid, context, target, internalformat, bufferPacked);
1011     }
1012 }
1013 
TexBufferRange(GLenum target,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size)1014 void GL_APIENTRY TexBufferRange(GLenum target,
1015                                 GLenum internalformat,
1016                                 GLuint buffer,
1017                                 GLintptr offset,
1018                                 GLsizeiptr size)
1019 {
1020     Context *context = GetValidGlobalContext();
1021     EVENT("glTexBufferRange",
1022           "context = %d, GLenum target = %s, GLenum internalformat = %s, GLuint buffer = %u, "
1023           "GLintptr offset = %llu, GLsizeiptr size = %llu",
1024           CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
1025           GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer,
1026           static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size));
1027 
1028     if (context)
1029     {
1030         BufferID bufferPacked                                 = FromGL<BufferID>(buffer);
1031         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1032         bool isCallValid =
1033             (context->skipValidation() ||
1034              ValidateTexBufferRange(context, target, internalformat, bufferPacked, offset, size));
1035         if (isCallValid)
1036         {
1037             context->texBufferRange(target, internalformat, bufferPacked, offset, size);
1038         }
1039         ANGLE_CAPTURE(TexBufferRange, isCallValid, context, target, internalformat, bufferPacked,
1040                       offset, size);
1041     }
1042 }
1043 
TexParameterIiv(GLenum target,GLenum pname,const GLint * params)1044 void GL_APIENTRY TexParameterIiv(GLenum target, GLenum pname, const GLint *params)
1045 {
1046     Context *context = GetValidGlobalContext();
1047     EVENT(
1048         "glTexParameterIiv",
1049         "context = %d, GLenum target = %s, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR
1050         "",
1051         CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
1052         GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
1053 
1054     if (context)
1055     {
1056         TextureType targetPacked                              = FromGL<TextureType>(target);
1057         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1058         bool isCallValid                                      = (context->skipValidation() ||
1059                             ValidateTexParameterIiv(context, targetPacked, pname, params));
1060         if (isCallValid)
1061         {
1062             context->texParameterIiv(targetPacked, pname, params);
1063         }
1064         ANGLE_CAPTURE(TexParameterIiv, isCallValid, context, targetPacked, pname, params);
1065     }
1066 }
1067 
TexParameterIuiv(GLenum target,GLenum pname,const GLuint * params)1068 void GL_APIENTRY TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
1069 {
1070     Context *context = GetValidGlobalContext();
1071     EVENT(
1072         "glTexParameterIuiv",
1073         "context = %d, GLenum target = %s, GLenum pname = %s, const GLuint *params = 0x%016" PRIxPTR
1074         "",
1075         CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
1076         GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params);
1077 
1078     if (context)
1079     {
1080         TextureType targetPacked                              = FromGL<TextureType>(target);
1081         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1082         bool isCallValid                                      = (context->skipValidation() ||
1083                             ValidateTexParameterIuiv(context, targetPacked, pname, params));
1084         if (isCallValid)
1085         {
1086             context->texParameterIuiv(targetPacked, pname, params);
1087         }
1088         ANGLE_CAPTURE(TexParameterIuiv, isCallValid, context, targetPacked, pname, params);
1089     }
1090 }
1091 
TexStorage3DMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)1092 void GL_APIENTRY TexStorage3DMultisample(GLenum target,
1093                                          GLsizei samples,
1094                                          GLenum internalformat,
1095                                          GLsizei width,
1096                                          GLsizei height,
1097                                          GLsizei depth,
1098                                          GLboolean fixedsamplelocations)
1099 {
1100     Context *context = GetValidGlobalContext();
1101     EVENT("glTexStorage3DMultisample",
1102           "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
1103           "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLboolean "
1104           "fixedsamplelocations = %s",
1105           CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
1106           GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth,
1107           GLbooleanToString(fixedsamplelocations));
1108 
1109     if (context)
1110     {
1111         TextureType targetPacked                              = FromGL<TextureType>(target);
1112         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1113         bool isCallValid =
1114             (context->skipValidation() ||
1115              ValidateTexStorage3DMultisample(context, targetPacked, samples, internalformat, width,
1116                                              height, depth, fixedsamplelocations));
1117         if (isCallValid)
1118         {
1119             context->texStorage3DMultisample(targetPacked, samples, internalformat, width, height,
1120                                              depth, fixedsamplelocations);
1121         }
1122         ANGLE_CAPTURE(TexStorage3DMultisample, isCallValid, context, targetPacked, samples,
1123                       internalformat, width, height, depth, fixedsamplelocations);
1124     }
1125 }
1126 }  // namespace gl
1127