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