1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml.
3 //
4 // Copyright 2019 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_gl_4_0_autogen.cpp:
9 // Defines the GL 4.0 entry points.
10
11 #include "libGL/entry_points_gl_4_0_autogen.h"
12
13 #include "libANGLE/Context.h"
14 #include "libANGLE/Context.inl.h"
15 #include "libANGLE/entry_points_utils.h"
16 #include "libANGLE/gl_enum_utils_autogen.h"
17 #include "libANGLE/validationEGL.h"
18 #include "libANGLE/validationES.h"
19 #include "libANGLE/validationES1.h"
20 #include "libANGLE/validationES2.h"
21 #include "libANGLE/validationES3.h"
22 #include "libANGLE/validationES31.h"
23 #include "libANGLE/validationESEXT.h"
24 #include "libANGLE/validationGL4_autogen.h"
25 #include "libGLESv2/global_state.h"
26
27 namespace gl
28 {
BeginQueryIndexed(GLenum target,GLuint index,GLuint id)29 void GL_APIENTRY BeginQueryIndexed(GLenum target, GLuint index, GLuint id)
30 {
31 EVENT("(GLenum target = %s, GLuint index = %u, GLuint id = %u)",
32 GLenumToString(GLenumGroup::QueryTarget, target), index, id);
33
34 Context *context = GetValidGlobalContext();
35 if (context)
36 {
37 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
38 bool isCallValid =
39 (context->skipValidation() || ValidateBeginQueryIndexed(context, target, index, id));
40 if (isCallValid)
41 {
42 context->beginQueryIndexed(target, index, id);
43 }
44 ANGLE_CAPTURE(BeginQueryIndexed, isCallValid, context, target, index, id);
45 }
46 }
47
BindTransformFeedback(GLenum target,GLuint id)48 void GL_APIENTRY BindTransformFeedback(GLenum target, GLuint id)
49 {
50 EVENT("(GLenum target = %s, GLuint id = %u)",
51 GLenumToString(GLenumGroup::BindTransformFeedbackTarget, target), id);
52
53 Context *context = GetValidGlobalContext();
54 if (context)
55 {
56 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
57 bool isCallValid =
58 (context->skipValidation() || ValidateBindTransformFeedback(context, target, id));
59 if (isCallValid)
60 {
61 context->bindTransformFeedback(target, id);
62 }
63 ANGLE_CAPTURE(BindTransformFeedback, isCallValid, context, target, id);
64 }
65 }
66
BlendEquationSeparatei(GLuint buf,GLenum modeRGB,GLenum modeAlpha)67 void GL_APIENTRY BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
68 {
69 EVENT("(GLuint buf = %u, GLenum modeRGB = %s, GLenum modeAlpha = %s)", buf,
70 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
71 GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
72
73 Context *context = GetValidGlobalContext();
74 if (context)
75 {
76 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
77 bool isCallValid = (context->skipValidation() ||
78 ValidateBlendEquationSeparatei(context, buf, modeRGB, modeAlpha));
79 if (isCallValid)
80 {
81 context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
82 }
83 ANGLE_CAPTURE(BlendEquationSeparatei, isCallValid, context, buf, modeRGB, modeAlpha);
84 }
85 }
86
BlendEquationi(GLuint buf,GLenum mode)87 void GL_APIENTRY BlendEquationi(GLuint buf, GLenum mode)
88 {
89 EVENT("(GLuint buf = %u, GLenum mode = %s)", buf,
90 GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
91
92 Context *context = GetValidGlobalContext();
93 if (context)
94 {
95 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
96 bool isCallValid =
97 (context->skipValidation() || ValidateBlendEquationi(context, buf, mode));
98 if (isCallValid)
99 {
100 context->blendEquationi(buf, mode);
101 }
102 ANGLE_CAPTURE(BlendEquationi, isCallValid, context, buf, mode);
103 }
104 }
105
106 void GL_APIENTRY
BlendFuncSeparatei(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)107 BlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
108 {
109 EVENT(
110 "(GLuint buf = %u, GLenum srcRGB = %s, GLenum dstRGB = %s, GLenum srcAlpha = %s, GLenum "
111 "dstAlpha = %s)",
112 buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
113 GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
114 GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
115 GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
116
117 Context *context = GetValidGlobalContext();
118 if (context)
119 {
120 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
121 bool isCallValid =
122 (context->skipValidation() ||
123 ValidateBlendFuncSeparatei(context, buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
124 if (isCallValid)
125 {
126 context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
127 }
128 ANGLE_CAPTURE(BlendFuncSeparatei, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
129 dstAlpha);
130 }
131 }
132
BlendFunci(GLuint buf,GLenum src,GLenum dst)133 void GL_APIENTRY BlendFunci(GLuint buf, GLenum src, GLenum dst)
134 {
135 EVENT("(GLuint buf = %u, GLenum src = %s, GLenum dst = %s)", buf,
136 GLenumToString(GLenumGroup::BlendingFactor, src),
137 GLenumToString(GLenumGroup::BlendingFactor, dst));
138
139 Context *context = GetValidGlobalContext();
140 if (context)
141 {
142 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
143 bool isCallValid =
144 (context->skipValidation() || ValidateBlendFunci(context, buf, src, dst));
145 if (isCallValid)
146 {
147 context->blendFunci(buf, src, dst);
148 }
149 ANGLE_CAPTURE(BlendFunci, isCallValid, context, buf, src, dst);
150 }
151 }
152
DeleteTransformFeedbacks(GLsizei n,const GLuint * ids)153 void GL_APIENTRY DeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
154 {
155 EVENT("(GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
156
157 Context *context = GetValidGlobalContext();
158 if (context)
159 {
160 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
161 bool isCallValid =
162 (context->skipValidation() || ValidateDeleteTransformFeedbacks(context, n, ids));
163 if (isCallValid)
164 {
165 context->deleteTransformFeedbacks(n, ids);
166 }
167 ANGLE_CAPTURE(DeleteTransformFeedbacks, isCallValid, context, n, ids);
168 }
169 }
170
DrawArraysIndirect(GLenum mode,const void * indirect)171 void GL_APIENTRY DrawArraysIndirect(GLenum mode, const void *indirect)
172 {
173 EVENT("(GLenum mode = %s, const void *indirect = 0x%016" PRIxPTR ")",
174 GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)indirect);
175
176 Context *context = GetValidGlobalContext();
177 if (context)
178 {
179 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
180 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
181 bool isCallValid = (context->skipValidation() ||
182 ValidateDrawArraysIndirect(context, modePacked, indirect));
183 if (isCallValid)
184 {
185 context->drawArraysIndirect(modePacked, indirect);
186 }
187 ANGLE_CAPTURE(DrawArraysIndirect, isCallValid, context, modePacked, indirect);
188 }
189 }
190
DrawElementsIndirect(GLenum mode,GLenum type,const void * indirect)191 void GL_APIENTRY DrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
192 {
193 EVENT("(GLenum mode = %s, GLenum type = %s, const void *indirect = 0x%016" PRIxPTR ")",
194 GLenumToString(GLenumGroup::PrimitiveType, mode),
195 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indirect);
196
197 Context *context = GetValidGlobalContext();
198 if (context)
199 {
200 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
201 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
202 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
203 bool isCallValid =
204 (context->skipValidation() ||
205 ValidateDrawElementsIndirect(context, modePacked, typePacked, indirect));
206 if (isCallValid)
207 {
208 context->drawElementsIndirect(modePacked, typePacked, indirect);
209 }
210 ANGLE_CAPTURE(DrawElementsIndirect, isCallValid, context, modePacked, typePacked, indirect);
211 }
212 }
213
DrawTransformFeedback(GLenum mode,GLuint id)214 void GL_APIENTRY DrawTransformFeedback(GLenum mode, GLuint id)
215 {
216 EVENT("(GLenum mode = %s, GLuint id = %u)", GLenumToString(GLenumGroup::PrimitiveType, mode),
217 id);
218
219 Context *context = GetValidGlobalContext();
220 if (context)
221 {
222 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
223 bool isCallValid =
224 (context->skipValidation() || ValidateDrawTransformFeedback(context, mode, id));
225 if (isCallValid)
226 {
227 context->drawTransformFeedback(mode, id);
228 }
229 ANGLE_CAPTURE(DrawTransformFeedback, isCallValid, context, mode, id);
230 }
231 }
232
DrawTransformFeedbackStream(GLenum mode,GLuint id,GLuint stream)233 void GL_APIENTRY DrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
234 {
235 EVENT("(GLenum mode = %s, GLuint id = %u, GLuint stream = %u)",
236 GLenumToString(GLenumGroup::PrimitiveType, mode), id, stream);
237
238 Context *context = GetValidGlobalContext();
239 if (context)
240 {
241 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
242 bool isCallValid = (context->skipValidation() ||
243 ValidateDrawTransformFeedbackStream(context, mode, id, stream));
244 if (isCallValid)
245 {
246 context->drawTransformFeedbackStream(mode, id, stream);
247 }
248 ANGLE_CAPTURE(DrawTransformFeedbackStream, isCallValid, context, mode, id, stream);
249 }
250 }
251
EndQueryIndexed(GLenum target,GLuint index)252 void GL_APIENTRY EndQueryIndexed(GLenum target, GLuint index)
253 {
254 EVENT("(GLenum target = %s, GLuint index = %u)",
255 GLenumToString(GLenumGroup::QueryTarget, target), index);
256
257 Context *context = GetValidGlobalContext();
258 if (context)
259 {
260 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
261 bool isCallValid =
262 (context->skipValidation() || ValidateEndQueryIndexed(context, target, index));
263 if (isCallValid)
264 {
265 context->endQueryIndexed(target, index);
266 }
267 ANGLE_CAPTURE(EndQueryIndexed, isCallValid, context, target, index);
268 }
269 }
270
GenTransformFeedbacks(GLsizei n,GLuint * ids)271 void GL_APIENTRY GenTransformFeedbacks(GLsizei n, GLuint *ids)
272 {
273 EVENT("(GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
274
275 Context *context = GetValidGlobalContext();
276 if (context)
277 {
278 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
279 bool isCallValid =
280 (context->skipValidation() || ValidateGenTransformFeedbacks(context, n, ids));
281 if (isCallValid)
282 {
283 context->genTransformFeedbacks(n, ids);
284 }
285 ANGLE_CAPTURE(GenTransformFeedbacks, isCallValid, context, n, ids);
286 }
287 }
288
GetActiveSubroutineName(GLuint program,GLenum shadertype,GLuint index,GLsizei bufsize,GLsizei * length,GLchar * name)289 void GL_APIENTRY GetActiveSubroutineName(GLuint program,
290 GLenum shadertype,
291 GLuint index,
292 GLsizei bufsize,
293 GLsizei *length,
294 GLchar *name)
295 {
296 EVENT(
297 "(GLuint program = %u, GLenum shadertype = %s, GLuint index = %u, GLsizei bufsize = %d, "
298 "GLsizei *length = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR ")",
299 program, GLenumToString(GLenumGroup::ShaderType, shadertype), index, bufsize,
300 (uintptr_t)length, (uintptr_t)name);
301
302 Context *context = GetValidGlobalContext();
303 if (context)
304 {
305 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
306 bool isCallValid = (context->skipValidation() ||
307 ValidateGetActiveSubroutineName(context, program, shadertype, index,
308 bufsize, length, name));
309 if (isCallValid)
310 {
311 context->getActiveSubroutineName(program, shadertype, index, bufsize, length, name);
312 }
313 ANGLE_CAPTURE(GetActiveSubroutineName, isCallValid, context, program, shadertype, index,
314 bufsize, length, name);
315 }
316 }
317
GetActiveSubroutineUniformName(GLuint program,GLenum shadertype,GLuint index,GLsizei bufsize,GLsizei * length,GLchar * name)318 void GL_APIENTRY GetActiveSubroutineUniformName(GLuint program,
319 GLenum shadertype,
320 GLuint index,
321 GLsizei bufsize,
322 GLsizei *length,
323 GLchar *name)
324 {
325 EVENT(
326 "(GLuint program = %u, GLenum shadertype = %s, GLuint index = %u, GLsizei bufsize = %d, "
327 "GLsizei *length = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR ")",
328 program, GLenumToString(GLenumGroup::ShaderType, shadertype), index, bufsize,
329 (uintptr_t)length, (uintptr_t)name);
330
331 Context *context = GetValidGlobalContext();
332 if (context)
333 {
334 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
335 bool isCallValid = (context->skipValidation() ||
336 ValidateGetActiveSubroutineUniformName(context, program, shadertype,
337 index, bufsize, length, name));
338 if (isCallValid)
339 {
340 context->getActiveSubroutineUniformName(program, shadertype, index, bufsize, length,
341 name);
342 }
343 ANGLE_CAPTURE(GetActiveSubroutineUniformName, isCallValid, context, program, shadertype,
344 index, bufsize, length, name);
345 }
346 }
347
GetActiveSubroutineUniformiv(GLuint program,GLenum shadertype,GLuint index,GLenum pname,GLint * values)348 void GL_APIENTRY GetActiveSubroutineUniformiv(GLuint program,
349 GLenum shadertype,
350 GLuint index,
351 GLenum pname,
352 GLint *values)
353 {
354 EVENT(
355 "(GLuint program = %u, GLenum shadertype = %s, GLuint index = %u, GLenum pname = %s, GLint "
356 "*values = 0x%016" PRIxPTR ")",
357 program, GLenumToString(GLenumGroup::ShaderType, shadertype), index,
358 GLenumToString(GLenumGroup::SubroutineParameterName, pname), (uintptr_t)values);
359
360 Context *context = GetValidGlobalContext();
361 if (context)
362 {
363 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
364 bool isCallValid =
365 (context->skipValidation() || ValidateGetActiveSubroutineUniformiv(
366 context, program, shadertype, index, pname, values));
367 if (isCallValid)
368 {
369 context->getActiveSubroutineUniformiv(program, shadertype, index, pname, values);
370 }
371 ANGLE_CAPTURE(GetActiveSubroutineUniformiv, isCallValid, context, program, shadertype,
372 index, pname, values);
373 }
374 }
375
GetProgramStageiv(GLuint program,GLenum shadertype,GLenum pname,GLint * values)376 void GL_APIENTRY GetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
377 {
378 EVENT(
379 "(GLuint program = %u, GLenum shadertype = %s, GLenum pname = %s, GLint *values = "
380 "0x%016" PRIxPTR ")",
381 program, GLenumToString(GLenumGroup::ShaderType, shadertype),
382 GLenumToString(GLenumGroup::ProgramStagePName, pname), (uintptr_t)values);
383
384 Context *context = GetValidGlobalContext();
385 if (context)
386 {
387 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
388 bool isCallValid = (context->skipValidation() ||
389 ValidateGetProgramStageiv(context, program, shadertype, pname, values));
390 if (isCallValid)
391 {
392 context->getProgramStageiv(program, shadertype, pname, values);
393 }
394 ANGLE_CAPTURE(GetProgramStageiv, isCallValid, context, program, shadertype, pname, values);
395 }
396 }
397
GetQueryIndexediv(GLenum target,GLuint index,GLenum pname,GLint * params)398 void GL_APIENTRY GetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
399 {
400 EVENT(
401 "(GLenum target = %s, GLuint index = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR
402 ")",
403 GLenumToString(GLenumGroup::DefaultGroup, target), index,
404 GLenumToString(GLenumGroup::QueryParameterName, pname), (uintptr_t)params);
405
406 Context *context = GetValidGlobalContext();
407 if (context)
408 {
409 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
410 bool isCallValid = (context->skipValidation() ||
411 ValidateGetQueryIndexediv(context, target, index, pname, params));
412 if (isCallValid)
413 {
414 context->getQueryIndexediv(target, index, pname, params);
415 }
416 ANGLE_CAPTURE(GetQueryIndexediv, isCallValid, context, target, index, pname, params);
417 }
418 }
419
GetSubroutineIndex(GLuint program,GLenum shadertype,const GLchar * name)420 GLuint GL_APIENTRY GetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
421 {
422 EVENT("(GLuint program = %u, GLenum shadertype = %s, const GLchar *name = 0x%016" PRIxPTR ")",
423 program, GLenumToString(GLenumGroup::ShaderType, shadertype), (uintptr_t)name);
424
425 Context *context = GetValidGlobalContext();
426 GLuint returnValue;
427 if (context)
428 {
429 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
430 bool isCallValid = (context->skipValidation() ||
431 ValidateGetSubroutineIndex(context, program, shadertype, name));
432 if (isCallValid)
433 {
434 returnValue = context->getSubroutineIndex(program, shadertype, name);
435 }
436 else
437 {
438 returnValue = GetDefaultReturnValue<EntryPoint::GetSubroutineIndex, GLuint>();
439 }
440 ANGLE_CAPTURE(GetSubroutineIndex, isCallValid, context, program, shadertype, name,
441 returnValue);
442 }
443 else
444 {
445 returnValue = GetDefaultReturnValue<EntryPoint::GetSubroutineIndex, GLuint>();
446 }
447 return returnValue;
448 }
449
GetSubroutineUniformLocation(GLuint program,GLenum shadertype,const GLchar * name)450 GLint GL_APIENTRY GetSubroutineUniformLocation(GLuint program,
451 GLenum shadertype,
452 const GLchar *name)
453 {
454 EVENT("(GLuint program = %u, GLenum shadertype = %s, const GLchar *name = 0x%016" PRIxPTR ")",
455 program, GLenumToString(GLenumGroup::ShaderType, shadertype), (uintptr_t)name);
456
457 Context *context = GetValidGlobalContext();
458 GLint returnValue;
459 if (context)
460 {
461 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
462 bool isCallValid = (context->skipValidation() || ValidateGetSubroutineUniformLocation(
463 context, program, shadertype, name));
464 if (isCallValid)
465 {
466 returnValue = context->getSubroutineUniformLocation(program, shadertype, name);
467 }
468 else
469 {
470 returnValue = GetDefaultReturnValue<EntryPoint::GetSubroutineUniformLocation, GLint>();
471 }
472 ANGLE_CAPTURE(GetSubroutineUniformLocation, isCallValid, context, program, shadertype, name,
473 returnValue);
474 }
475 else
476 {
477 returnValue = GetDefaultReturnValue<EntryPoint::GetSubroutineUniformLocation, GLint>();
478 }
479 return returnValue;
480 }
481
GetUniformSubroutineuiv(GLenum shadertype,GLint location,GLuint * params)482 void GL_APIENTRY GetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
483 {
484 EVENT("(GLenum shadertype = %s, GLint location = %d, GLuint *params = 0x%016" PRIxPTR ")",
485 GLenumToString(GLenumGroup::ShaderType, shadertype), location, (uintptr_t)params);
486
487 Context *context = GetValidGlobalContext();
488 if (context)
489 {
490 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
491 bool isCallValid = (context->skipValidation() ||
492 ValidateGetUniformSubroutineuiv(context, shadertype, location, params));
493 if (isCallValid)
494 {
495 context->getUniformSubroutineuiv(shadertype, location, params);
496 }
497 ANGLE_CAPTURE(GetUniformSubroutineuiv, isCallValid, context, shadertype, location, params);
498 }
499 }
500
GetUniformdv(GLuint program,GLint location,GLdouble * params)501 void GL_APIENTRY GetUniformdv(GLuint program, GLint location, GLdouble *params)
502 {
503 EVENT("(GLuint program = %u, GLint location = %d, GLdouble *params = 0x%016" PRIxPTR ")",
504 program, location, (uintptr_t)params);
505
506 Context *context = GetValidGlobalContext();
507 if (context)
508 {
509 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
510 bool isCallValid =
511 (context->skipValidation() || ValidateGetUniformdv(context, program, location, params));
512 if (isCallValid)
513 {
514 context->getUniformdv(program, location, params);
515 }
516 ANGLE_CAPTURE(GetUniformdv, isCallValid, context, program, location, params);
517 }
518 }
519
IsTransformFeedback(GLuint id)520 GLboolean GL_APIENTRY IsTransformFeedback(GLuint id)
521 {
522 EVENT("(GLuint id = %u)", id);
523
524 Context *context = GetValidGlobalContext();
525 GLboolean returnValue;
526 if (context)
527 {
528 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
529 bool isCallValid = (context->skipValidation() || ValidateIsTransformFeedback(context, id));
530 if (isCallValid)
531 {
532 returnValue = context->isTransformFeedback(id);
533 }
534 else
535 {
536 returnValue = GetDefaultReturnValue<EntryPoint::IsTransformFeedback, GLboolean>();
537 }
538 ANGLE_CAPTURE(IsTransformFeedback, isCallValid, context, id, returnValue);
539 }
540 else
541 {
542 returnValue = GetDefaultReturnValue<EntryPoint::IsTransformFeedback, GLboolean>();
543 }
544 return returnValue;
545 }
546
MinSampleShading(GLfloat value)547 void GL_APIENTRY MinSampleShading(GLfloat value)
548 {
549 EVENT("(GLfloat value = %f)", value);
550
551 Context *context = GetValidGlobalContext();
552 if (context)
553 {
554 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
555 bool isCallValid = (context->skipValidation() || ValidateMinSampleShading(context, value));
556 if (isCallValid)
557 {
558 context->minSampleShading(value);
559 }
560 ANGLE_CAPTURE(MinSampleShading, isCallValid, context, value);
561 }
562 }
563
PatchParameterfv(GLenum pname,const GLfloat * values)564 void GL_APIENTRY PatchParameterfv(GLenum pname, const GLfloat *values)
565 {
566 EVENT("(GLenum pname = %s, const GLfloat *values = 0x%016" PRIxPTR ")",
567 GLenumToString(GLenumGroup::PatchParameterName, pname), (uintptr_t)values);
568
569 Context *context = GetValidGlobalContext();
570 if (context)
571 {
572 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
573 bool isCallValid =
574 (context->skipValidation() || ValidatePatchParameterfv(context, pname, values));
575 if (isCallValid)
576 {
577 context->patchParameterfv(pname, values);
578 }
579 ANGLE_CAPTURE(PatchParameterfv, isCallValid, context, pname, values);
580 }
581 }
582
PatchParameteri(GLenum pname,GLint value)583 void GL_APIENTRY PatchParameteri(GLenum pname, GLint value)
584 {
585 EVENT("(GLenum pname = %s, GLint value = %d)",
586 GLenumToString(GLenumGroup::PatchParameterName, pname), value);
587
588 Context *context = GetValidGlobalContext();
589 if (context)
590 {
591 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
592 bool isCallValid =
593 (context->skipValidation() || ValidatePatchParameteri(context, pname, value));
594 if (isCallValid)
595 {
596 context->patchParameteri(pname, value);
597 }
598 ANGLE_CAPTURE(PatchParameteri, isCallValid, context, pname, value);
599 }
600 }
601
PauseTransformFeedback()602 void GL_APIENTRY PauseTransformFeedback()
603 {
604 EVENT("()");
605
606 Context *context = GetValidGlobalContext();
607 if (context)
608 {
609 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
610 bool isCallValid = (context->skipValidation() || ValidatePauseTransformFeedback(context));
611 if (isCallValid)
612 {
613 context->pauseTransformFeedback();
614 }
615 ANGLE_CAPTURE(PauseTransformFeedback, isCallValid, context);
616 }
617 }
618
ResumeTransformFeedback()619 void GL_APIENTRY ResumeTransformFeedback()
620 {
621 EVENT("()");
622
623 Context *context = GetValidGlobalContext();
624 if (context)
625 {
626 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
627 bool isCallValid = (context->skipValidation() || ValidateResumeTransformFeedback(context));
628 if (isCallValid)
629 {
630 context->resumeTransformFeedback();
631 }
632 ANGLE_CAPTURE(ResumeTransformFeedback, isCallValid, context);
633 }
634 }
635
Uniform1d(GLint location,GLdouble x)636 void GL_APIENTRY Uniform1d(GLint location, GLdouble x)
637 {
638 EVENT("(GLint location = %d, GLdouble x = %f)", location, x);
639
640 Context *context = GetValidGlobalContext();
641 if (context)
642 {
643 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
644 bool isCallValid = (context->skipValidation() || ValidateUniform1d(context, location, x));
645 if (isCallValid)
646 {
647 context->uniform1d(location, x);
648 }
649 ANGLE_CAPTURE(Uniform1d, isCallValid, context, location, x);
650 }
651 }
652
Uniform1dv(GLint location,GLsizei count,const GLdouble * value)653 void GL_APIENTRY Uniform1dv(GLint location, GLsizei count, const GLdouble *value)
654 {
655 EVENT("(GLint location = %d, GLsizei count = %d, const GLdouble *value = 0x%016" PRIxPTR ")",
656 location, count, (uintptr_t)value);
657
658 Context *context = GetValidGlobalContext();
659 if (context)
660 {
661 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
662 bool isCallValid =
663 (context->skipValidation() || ValidateUniform1dv(context, location, count, value));
664 if (isCallValid)
665 {
666 context->uniform1dv(location, count, value);
667 }
668 ANGLE_CAPTURE(Uniform1dv, isCallValid, context, location, count, value);
669 }
670 }
671
Uniform2d(GLint location,GLdouble x,GLdouble y)672 void GL_APIENTRY Uniform2d(GLint location, GLdouble x, GLdouble y)
673 {
674 EVENT("(GLint location = %d, GLdouble x = %f, GLdouble y = %f)", location, x, y);
675
676 Context *context = GetValidGlobalContext();
677 if (context)
678 {
679 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
680 bool isCallValid =
681 (context->skipValidation() || ValidateUniform2d(context, location, x, y));
682 if (isCallValid)
683 {
684 context->uniform2d(location, x, y);
685 }
686 ANGLE_CAPTURE(Uniform2d, isCallValid, context, location, x, y);
687 }
688 }
689
Uniform2dv(GLint location,GLsizei count,const GLdouble * value)690 void GL_APIENTRY Uniform2dv(GLint location, GLsizei count, const GLdouble *value)
691 {
692 EVENT("(GLint location = %d, GLsizei count = %d, const GLdouble *value = 0x%016" PRIxPTR ")",
693 location, count, (uintptr_t)value);
694
695 Context *context = GetValidGlobalContext();
696 if (context)
697 {
698 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
699 bool isCallValid =
700 (context->skipValidation() || ValidateUniform2dv(context, location, count, value));
701 if (isCallValid)
702 {
703 context->uniform2dv(location, count, value);
704 }
705 ANGLE_CAPTURE(Uniform2dv, isCallValid, context, location, count, value);
706 }
707 }
708
Uniform3d(GLint location,GLdouble x,GLdouble y,GLdouble z)709 void GL_APIENTRY Uniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
710 {
711 EVENT("(GLint location = %d, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f)", location, x,
712 y, z);
713
714 Context *context = GetValidGlobalContext();
715 if (context)
716 {
717 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
718 bool isCallValid =
719 (context->skipValidation() || ValidateUniform3d(context, location, x, y, z));
720 if (isCallValid)
721 {
722 context->uniform3d(location, x, y, z);
723 }
724 ANGLE_CAPTURE(Uniform3d, isCallValid, context, location, x, y, z);
725 }
726 }
727
Uniform3dv(GLint location,GLsizei count,const GLdouble * value)728 void GL_APIENTRY Uniform3dv(GLint location, GLsizei count, const GLdouble *value)
729 {
730 EVENT("(GLint location = %d, GLsizei count = %d, const GLdouble *value = 0x%016" PRIxPTR ")",
731 location, count, (uintptr_t)value);
732
733 Context *context = GetValidGlobalContext();
734 if (context)
735 {
736 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
737 bool isCallValid =
738 (context->skipValidation() || ValidateUniform3dv(context, location, count, value));
739 if (isCallValid)
740 {
741 context->uniform3dv(location, count, value);
742 }
743 ANGLE_CAPTURE(Uniform3dv, isCallValid, context, location, count, value);
744 }
745 }
746
Uniform4d(GLint location,GLdouble x,GLdouble y,GLdouble z,GLdouble w)747 void GL_APIENTRY Uniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
748 {
749 EVENT(
750 "(GLint location = %d, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f, GLdouble w = %f)",
751 location, x, y, z, w);
752
753 Context *context = GetValidGlobalContext();
754 if (context)
755 {
756 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
757 bool isCallValid =
758 (context->skipValidation() || ValidateUniform4d(context, location, x, y, z, w));
759 if (isCallValid)
760 {
761 context->uniform4d(location, x, y, z, w);
762 }
763 ANGLE_CAPTURE(Uniform4d, isCallValid, context, location, x, y, z, w);
764 }
765 }
766
Uniform4dv(GLint location,GLsizei count,const GLdouble * value)767 void GL_APIENTRY Uniform4dv(GLint location, GLsizei count, const GLdouble *value)
768 {
769 EVENT("(GLint location = %d, GLsizei count = %d, const GLdouble *value = 0x%016" PRIxPTR ")",
770 location, count, (uintptr_t)value);
771
772 Context *context = GetValidGlobalContext();
773 if (context)
774 {
775 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
776 bool isCallValid =
777 (context->skipValidation() || ValidateUniform4dv(context, location, count, value));
778 if (isCallValid)
779 {
780 context->uniform4dv(location, count, value);
781 }
782 ANGLE_CAPTURE(Uniform4dv, isCallValid, context, location, count, value);
783 }
784 }
785
UniformMatrix2dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)786 void GL_APIENTRY UniformMatrix2dv(GLint location,
787 GLsizei count,
788 GLboolean transpose,
789 const GLdouble *value)
790 {
791 EVENT(
792 "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const GLdouble *value "
793 "= 0x%016" PRIxPTR ")",
794 location, count, GLbooleanToString(transpose), (uintptr_t)value);
795
796 Context *context = GetValidGlobalContext();
797 if (context)
798 {
799 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
800 bool isCallValid = (context->skipValidation() ||
801 ValidateUniformMatrix2dv(context, location, count, transpose, value));
802 if (isCallValid)
803 {
804 context->uniformMatrix2dv(location, count, transpose, value);
805 }
806 ANGLE_CAPTURE(UniformMatrix2dv, isCallValid, context, location, count, transpose, value);
807 }
808 }
809
UniformMatrix2x3dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)810 void GL_APIENTRY UniformMatrix2x3dv(GLint location,
811 GLsizei count,
812 GLboolean transpose,
813 const GLdouble *value)
814 {
815 EVENT(
816 "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const GLdouble *value "
817 "= 0x%016" PRIxPTR ")",
818 location, count, GLbooleanToString(transpose), (uintptr_t)value);
819
820 Context *context = GetValidGlobalContext();
821 if (context)
822 {
823 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
824 bool isCallValid = (context->skipValidation() ||
825 ValidateUniformMatrix2x3dv(context, location, count, transpose, value));
826 if (isCallValid)
827 {
828 context->uniformMatrix2x3dv(location, count, transpose, value);
829 }
830 ANGLE_CAPTURE(UniformMatrix2x3dv, isCallValid, context, location, count, transpose, value);
831 }
832 }
833
UniformMatrix2x4dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)834 void GL_APIENTRY UniformMatrix2x4dv(GLint location,
835 GLsizei count,
836 GLboolean transpose,
837 const GLdouble *value)
838 {
839 EVENT(
840 "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const GLdouble *value "
841 "= 0x%016" PRIxPTR ")",
842 location, count, GLbooleanToString(transpose), (uintptr_t)value);
843
844 Context *context = GetValidGlobalContext();
845 if (context)
846 {
847 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
848 bool isCallValid = (context->skipValidation() ||
849 ValidateUniformMatrix2x4dv(context, location, count, transpose, value));
850 if (isCallValid)
851 {
852 context->uniformMatrix2x4dv(location, count, transpose, value);
853 }
854 ANGLE_CAPTURE(UniformMatrix2x4dv, isCallValid, context, location, count, transpose, value);
855 }
856 }
857
UniformMatrix3dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)858 void GL_APIENTRY UniformMatrix3dv(GLint location,
859 GLsizei count,
860 GLboolean transpose,
861 const GLdouble *value)
862 {
863 EVENT(
864 "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const GLdouble *value "
865 "= 0x%016" PRIxPTR ")",
866 location, count, GLbooleanToString(transpose), (uintptr_t)value);
867
868 Context *context = GetValidGlobalContext();
869 if (context)
870 {
871 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
872 bool isCallValid = (context->skipValidation() ||
873 ValidateUniformMatrix3dv(context, location, count, transpose, value));
874 if (isCallValid)
875 {
876 context->uniformMatrix3dv(location, count, transpose, value);
877 }
878 ANGLE_CAPTURE(UniformMatrix3dv, isCallValid, context, location, count, transpose, value);
879 }
880 }
881
UniformMatrix3x2dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)882 void GL_APIENTRY UniformMatrix3x2dv(GLint location,
883 GLsizei count,
884 GLboolean transpose,
885 const GLdouble *value)
886 {
887 EVENT(
888 "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const GLdouble *value "
889 "= 0x%016" PRIxPTR ")",
890 location, count, GLbooleanToString(transpose), (uintptr_t)value);
891
892 Context *context = GetValidGlobalContext();
893 if (context)
894 {
895 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
896 bool isCallValid = (context->skipValidation() ||
897 ValidateUniformMatrix3x2dv(context, location, count, transpose, value));
898 if (isCallValid)
899 {
900 context->uniformMatrix3x2dv(location, count, transpose, value);
901 }
902 ANGLE_CAPTURE(UniformMatrix3x2dv, isCallValid, context, location, count, transpose, value);
903 }
904 }
905
UniformMatrix3x4dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)906 void GL_APIENTRY UniformMatrix3x4dv(GLint location,
907 GLsizei count,
908 GLboolean transpose,
909 const GLdouble *value)
910 {
911 EVENT(
912 "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const GLdouble *value "
913 "= 0x%016" PRIxPTR ")",
914 location, count, GLbooleanToString(transpose), (uintptr_t)value);
915
916 Context *context = GetValidGlobalContext();
917 if (context)
918 {
919 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
920 bool isCallValid = (context->skipValidation() ||
921 ValidateUniformMatrix3x4dv(context, location, count, transpose, value));
922 if (isCallValid)
923 {
924 context->uniformMatrix3x4dv(location, count, transpose, value);
925 }
926 ANGLE_CAPTURE(UniformMatrix3x4dv, isCallValid, context, location, count, transpose, value);
927 }
928 }
929
UniformMatrix4dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)930 void GL_APIENTRY UniformMatrix4dv(GLint location,
931 GLsizei count,
932 GLboolean transpose,
933 const GLdouble *value)
934 {
935 EVENT(
936 "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const GLdouble *value "
937 "= 0x%016" PRIxPTR ")",
938 location, count, GLbooleanToString(transpose), (uintptr_t)value);
939
940 Context *context = GetValidGlobalContext();
941 if (context)
942 {
943 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
944 bool isCallValid = (context->skipValidation() ||
945 ValidateUniformMatrix4dv(context, location, count, transpose, value));
946 if (isCallValid)
947 {
948 context->uniformMatrix4dv(location, count, transpose, value);
949 }
950 ANGLE_CAPTURE(UniformMatrix4dv, isCallValid, context, location, count, transpose, value);
951 }
952 }
953
UniformMatrix4x2dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)954 void GL_APIENTRY UniformMatrix4x2dv(GLint location,
955 GLsizei count,
956 GLboolean transpose,
957 const GLdouble *value)
958 {
959 EVENT(
960 "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const GLdouble *value "
961 "= 0x%016" PRIxPTR ")",
962 location, count, GLbooleanToString(transpose), (uintptr_t)value);
963
964 Context *context = GetValidGlobalContext();
965 if (context)
966 {
967 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
968 bool isCallValid = (context->skipValidation() ||
969 ValidateUniformMatrix4x2dv(context, location, count, transpose, value));
970 if (isCallValid)
971 {
972 context->uniformMatrix4x2dv(location, count, transpose, value);
973 }
974 ANGLE_CAPTURE(UniformMatrix4x2dv, isCallValid, context, location, count, transpose, value);
975 }
976 }
977
UniformMatrix4x3dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)978 void GL_APIENTRY UniformMatrix4x3dv(GLint location,
979 GLsizei count,
980 GLboolean transpose,
981 const GLdouble *value)
982 {
983 EVENT(
984 "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const GLdouble *value "
985 "= 0x%016" PRIxPTR ")",
986 location, count, GLbooleanToString(transpose), (uintptr_t)value);
987
988 Context *context = GetValidGlobalContext();
989 if (context)
990 {
991 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
992 bool isCallValid = (context->skipValidation() ||
993 ValidateUniformMatrix4x3dv(context, location, count, transpose, value));
994 if (isCallValid)
995 {
996 context->uniformMatrix4x3dv(location, count, transpose, value);
997 }
998 ANGLE_CAPTURE(UniformMatrix4x3dv, isCallValid, context, location, count, transpose, value);
999 }
1000 }
1001
UniformSubroutinesuiv(GLenum shadertype,GLsizei count,const GLuint * indices)1002 void GL_APIENTRY UniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
1003 {
1004 EVENT("(GLenum shadertype = %s, GLsizei count = %d, const GLuint *indices = 0x%016" PRIxPTR ")",
1005 GLenumToString(GLenumGroup::ShaderType, shadertype), count, (uintptr_t)indices);
1006
1007 Context *context = GetValidGlobalContext();
1008 if (context)
1009 {
1010 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1011 bool isCallValid = (context->skipValidation() ||
1012 ValidateUniformSubroutinesuiv(context, shadertype, count, indices));
1013 if (isCallValid)
1014 {
1015 context->uniformSubroutinesuiv(shadertype, count, indices);
1016 }
1017 ANGLE_CAPTURE(UniformSubroutinesuiv, isCallValid, context, shadertype, count, indices);
1018 }
1019 }
1020 } // namespace gl
1021