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_1_autogen.cpp:
9 // Defines the GL 4.1 entry points.
10
11 #include "libGL/entry_points_gl_4_1_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/validationGL41_autogen.h"
25 #include "libGLESv2/global_state.h"
26
27 namespace gl
28 {
ActiveShaderProgram(GLuint pipeline,GLuint program)29 void GL_APIENTRY ActiveShaderProgram(GLuint pipeline, GLuint program)
30 {
31 EVENT("(GLuint pipeline = %u, GLuint program = %u)", pipeline, program);
32
33 Context *context = GetValidGlobalContext();
34 if (context)
35 {
36 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
37 bool isCallValid =
38 (context->skipValidation() || ValidateActiveShaderProgram(context, pipeline, program));
39 if (isCallValid)
40 {
41 context->activeShaderProgram(pipeline, program);
42 }
43 ANGLE_CAPTURE(ActiveShaderProgram, isCallValid, context, pipeline, program);
44 }
45 }
46
BindProgramPipeline(GLuint pipeline)47 void GL_APIENTRY BindProgramPipeline(GLuint pipeline)
48 {
49 EVENT("(GLuint pipeline = %u)", pipeline);
50
51 Context *context = GetValidGlobalContext();
52 if (context)
53 {
54 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
55 bool isCallValid =
56 (context->skipValidation() || ValidateBindProgramPipeline(context, pipeline));
57 if (isCallValid)
58 {
59 context->bindProgramPipeline(pipeline);
60 }
61 ANGLE_CAPTURE(BindProgramPipeline, isCallValid, context, pipeline);
62 }
63 }
64
ClearDepthf(GLfloat d)65 void GL_APIENTRY ClearDepthf(GLfloat d)
66 {
67 EVENT("(GLfloat d = %f)", d);
68
69 Context *context = GetValidGlobalContext();
70 if (context)
71 {
72 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
73 bool isCallValid = (context->skipValidation() || ValidateClearDepthf(context, d));
74 if (isCallValid)
75 {
76 context->clearDepthf(d);
77 }
78 ANGLE_CAPTURE(ClearDepthf, isCallValid, context, d);
79 }
80 }
81
CreateShaderProgramv(GLenum type,GLsizei count,const GLchar * const * strings)82 GLuint GL_APIENTRY CreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
83 {
84 EVENT("(GLenum type = %s, GLsizei count = %d, const GLchar *const*strings = 0x%016" PRIxPTR ")",
85 GLenumToString(GLenumGroup::ShaderType, type), count, (uintptr_t)strings);
86
87 Context *context = GetValidGlobalContext();
88 GLuint returnValue;
89 if (context)
90 {
91 ShaderType typePacked = FromGL<ShaderType>(type);
92 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
93 bool isCallValid = (context->skipValidation() ||
94 ValidateCreateShaderProgramv(context, typePacked, count, strings));
95 if (isCallValid)
96 {
97 returnValue = context->createShaderProgramv(typePacked, count, strings);
98 }
99 else
100 {
101 returnValue = GetDefaultReturnValue<EntryPoint::CreateShaderProgramv, GLuint>();
102 }
103 ANGLE_CAPTURE(CreateShaderProgramv, isCallValid, context, typePacked, count, strings,
104 returnValue);
105 }
106 else
107 {
108 returnValue = GetDefaultReturnValue<EntryPoint::CreateShaderProgramv, GLuint>();
109 }
110 return returnValue;
111 }
112
DeleteProgramPipelines(GLsizei n,const GLuint * pipelines)113 void GL_APIENTRY DeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
114 {
115 EVENT("(GLsizei n = %d, const GLuint *pipelines = 0x%016" PRIxPTR ")", n, (uintptr_t)pipelines);
116
117 Context *context = GetValidGlobalContext();
118 if (context)
119 {
120 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
121 bool isCallValid =
122 (context->skipValidation() || ValidateDeleteProgramPipelines(context, n, pipelines));
123 if (isCallValid)
124 {
125 context->deleteProgramPipelines(n, pipelines);
126 }
127 ANGLE_CAPTURE(DeleteProgramPipelines, isCallValid, context, n, pipelines);
128 }
129 }
130
DepthRangeArrayv(GLuint first,GLsizei count,const GLdouble * v)131 void GL_APIENTRY DepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
132 {
133 EVENT("(GLuint first = %u, GLsizei count = %d, const GLdouble *v = 0x%016" PRIxPTR ")", first,
134 count, (uintptr_t)v);
135
136 Context *context = GetValidGlobalContext();
137 if (context)
138 {
139 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
140 bool isCallValid =
141 (context->skipValidation() || ValidateDepthRangeArrayv(context, first, count, v));
142 if (isCallValid)
143 {
144 context->depthRangeArrayv(first, count, v);
145 }
146 ANGLE_CAPTURE(DepthRangeArrayv, isCallValid, context, first, count, v);
147 }
148 }
149
DepthRangeIndexed(GLuint index,GLdouble n,GLdouble f)150 void GL_APIENTRY DepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
151 {
152 EVENT("(GLuint index = %u, GLdouble n = %f, GLdouble f = %f)", index, n, f);
153
154 Context *context = GetValidGlobalContext();
155 if (context)
156 {
157 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
158 bool isCallValid =
159 (context->skipValidation() || ValidateDepthRangeIndexed(context, index, n, f));
160 if (isCallValid)
161 {
162 context->depthRangeIndexed(index, n, f);
163 }
164 ANGLE_CAPTURE(DepthRangeIndexed, isCallValid, context, index, n, f);
165 }
166 }
167
DepthRangef(GLfloat n,GLfloat f)168 void GL_APIENTRY DepthRangef(GLfloat n, GLfloat f)
169 {
170 EVENT("(GLfloat n = %f, GLfloat f = %f)", n, f);
171
172 Context *context = GetValidGlobalContext();
173 if (context)
174 {
175 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
176 bool isCallValid = (context->skipValidation() || ValidateDepthRangef(context, n, f));
177 if (isCallValid)
178 {
179 context->depthRangef(n, f);
180 }
181 ANGLE_CAPTURE(DepthRangef, isCallValid, context, n, f);
182 }
183 }
184
GenProgramPipelines(GLsizei n,GLuint * pipelines)185 void GL_APIENTRY GenProgramPipelines(GLsizei n, GLuint *pipelines)
186 {
187 EVENT("(GLsizei n = %d, GLuint *pipelines = 0x%016" PRIxPTR ")", n, (uintptr_t)pipelines);
188
189 Context *context = GetValidGlobalContext();
190 if (context)
191 {
192 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
193 bool isCallValid =
194 (context->skipValidation() || ValidateGenProgramPipelines(context, n, pipelines));
195 if (isCallValid)
196 {
197 context->genProgramPipelines(n, pipelines);
198 }
199 ANGLE_CAPTURE(GenProgramPipelines, isCallValid, context, n, pipelines);
200 }
201 }
202
GetDoublei_v(GLenum target,GLuint index,GLdouble * data)203 void GL_APIENTRY GetDoublei_v(GLenum target, GLuint index, GLdouble *data)
204 {
205 EVENT("(GLenum target = %s, GLuint index = %u, GLdouble *data = 0x%016" PRIxPTR ")",
206 GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data);
207
208 Context *context = GetValidGlobalContext();
209 if (context)
210 {
211 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
212 bool isCallValid =
213 (context->skipValidation() || ValidateGetDoublei_v(context, target, index, data));
214 if (isCallValid)
215 {
216 context->getDoublei_v(target, index, data);
217 }
218 ANGLE_CAPTURE(GetDoublei_v, isCallValid, context, target, index, data);
219 }
220 }
221
GetFloati_v(GLenum target,GLuint index,GLfloat * data)222 void GL_APIENTRY GetFloati_v(GLenum target, GLuint index, GLfloat *data)
223 {
224 EVENT("(GLenum target = %s, GLuint index = %u, GLfloat *data = 0x%016" PRIxPTR ")",
225 GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data);
226
227 Context *context = GetValidGlobalContext();
228 if (context)
229 {
230 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
231 bool isCallValid =
232 (context->skipValidation() || ValidateGetFloati_v(context, target, index, data));
233 if (isCallValid)
234 {
235 context->getFloati_v(target, index, data);
236 }
237 ANGLE_CAPTURE(GetFloati_v, isCallValid, context, target, index, data);
238 }
239 }
240
GetProgramBinary(GLuint program,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)241 void GL_APIENTRY GetProgramBinary(GLuint program,
242 GLsizei bufSize,
243 GLsizei *length,
244 GLenum *binaryFormat,
245 void *binary)
246 {
247 EVENT("(GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
248 ", GLenum *binaryFormat = 0x%016" PRIxPTR ", void *binary = 0x%016" PRIxPTR ")",
249 program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat, (uintptr_t)binary);
250
251 Context *context = GetValidGlobalContext();
252 if (context)
253 {
254 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
255 bool isCallValid =
256 (context->skipValidation() ||
257 ValidateGetProgramBinary(context, program, bufSize, length, binaryFormat, binary));
258 if (isCallValid)
259 {
260 context->getProgramBinary(program, bufSize, length, binaryFormat, binary);
261 }
262 ANGLE_CAPTURE(GetProgramBinary, isCallValid, context, program, bufSize, length,
263 binaryFormat, binary);
264 }
265 }
266
GetProgramPipelineInfoLog(GLuint pipeline,GLsizei bufSize,GLsizei * length,GLchar * infoLog)267 void GL_APIENTRY GetProgramPipelineInfoLog(GLuint pipeline,
268 GLsizei bufSize,
269 GLsizei *length,
270 GLchar *infoLog)
271 {
272 EVENT("(GLuint pipeline = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
273 ", GLchar *infoLog = 0x%016" PRIxPTR ")",
274 pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
275
276 Context *context = GetValidGlobalContext();
277 if (context)
278 {
279 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
280 bool isCallValid =
281 (context->skipValidation() ||
282 ValidateGetProgramPipelineInfoLog(context, pipeline, bufSize, length, infoLog));
283 if (isCallValid)
284 {
285 context->getProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
286 }
287 ANGLE_CAPTURE(GetProgramPipelineInfoLog, isCallValid, context, pipeline, bufSize, length,
288 infoLog);
289 }
290 }
291
GetProgramPipelineiv(GLuint pipeline,GLenum pname,GLint * params)292 void GL_APIENTRY GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
293 {
294 EVENT("(GLuint pipeline = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR ")", pipeline,
295 GLenumToString(GLenumGroup::PipelineParameterName, pname), (uintptr_t)params);
296
297 Context *context = GetValidGlobalContext();
298 if (context)
299 {
300 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
301 bool isCallValid = (context->skipValidation() ||
302 ValidateGetProgramPipelineiv(context, pipeline, pname, params));
303 if (isCallValid)
304 {
305 context->getProgramPipelineiv(pipeline, pname, params);
306 }
307 ANGLE_CAPTURE(GetProgramPipelineiv, isCallValid, context, pipeline, pname, params);
308 }
309 }
310
GetShaderPrecisionFormat(GLenum shadertype,GLenum precisiontype,GLint * range,GLint * precision)311 void GL_APIENTRY GetShaderPrecisionFormat(GLenum shadertype,
312 GLenum precisiontype,
313 GLint *range,
314 GLint *precision)
315 {
316 EVENT("(GLenum shadertype = %s, GLenum precisiontype = %s, GLint *range = 0x%016" PRIxPTR
317 ", GLint *precision = 0x%016" PRIxPTR ")",
318 GLenumToString(GLenumGroup::ShaderType, shadertype),
319 GLenumToString(GLenumGroup::PrecisionType, precisiontype), (uintptr_t)range,
320 (uintptr_t)precision);
321
322 Context *context = GetValidGlobalContext();
323 if (context)
324 {
325 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
326 bool isCallValid = (context->skipValidation() ||
327 ValidateGetShaderPrecisionFormat(context, shadertype, precisiontype,
328 range, precision));
329 if (isCallValid)
330 {
331 context->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
332 }
333 ANGLE_CAPTURE(GetShaderPrecisionFormat, isCallValid, context, shadertype, precisiontype,
334 range, precision);
335 }
336 }
337
GetVertexAttribLdv(GLuint index,GLenum pname,GLdouble * params)338 void GL_APIENTRY GetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
339 {
340 EVENT("(GLuint index = %u, GLenum pname = %s, GLdouble *params = 0x%016" PRIxPTR ")", index,
341 GLenumToString(GLenumGroup::VertexAttribEnum, pname), (uintptr_t)params);
342
343 Context *context = GetValidGlobalContext();
344 if (context)
345 {
346 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
347 bool isCallValid = (context->skipValidation() ||
348 ValidateGetVertexAttribLdv(context, index, pname, params));
349 if (isCallValid)
350 {
351 context->getVertexAttribLdv(index, pname, params);
352 }
353 ANGLE_CAPTURE(GetVertexAttribLdv, isCallValid, context, index, pname, params);
354 }
355 }
356
IsProgramPipeline(GLuint pipeline)357 GLboolean GL_APIENTRY IsProgramPipeline(GLuint pipeline)
358 {
359 EVENT("(GLuint pipeline = %u)", pipeline);
360
361 Context *context = GetValidGlobalContext();
362 GLboolean returnValue;
363 if (context)
364 {
365 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
366 bool isCallValid =
367 (context->skipValidation() || ValidateIsProgramPipeline(context, pipeline));
368 if (isCallValid)
369 {
370 returnValue = context->isProgramPipeline(pipeline);
371 }
372 else
373 {
374 returnValue = GetDefaultReturnValue<EntryPoint::IsProgramPipeline, GLboolean>();
375 }
376 ANGLE_CAPTURE(IsProgramPipeline, isCallValid, context, pipeline, returnValue);
377 }
378 else
379 {
380 returnValue = GetDefaultReturnValue<EntryPoint::IsProgramPipeline, GLboolean>();
381 }
382 return returnValue;
383 }
384
ProgramBinary(GLuint program,GLenum binaryFormat,const void * binary,GLsizei length)385 void GL_APIENTRY ProgramBinary(GLuint program,
386 GLenum binaryFormat,
387 const void *binary,
388 GLsizei length)
389 {
390 EVENT("(GLuint program = %u, GLenum binaryFormat = %s, const void *binary = 0x%016" PRIxPTR
391 ", GLsizei length = %d)",
392 program, GLenumToString(GLenumGroup::DefaultGroup, binaryFormat), (uintptr_t)binary,
393 length);
394
395 Context *context = GetValidGlobalContext();
396 if (context)
397 {
398 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
399 bool isCallValid = (context->skipValidation() ||
400 ValidateProgramBinary(context, program, binaryFormat, binary, length));
401 if (isCallValid)
402 {
403 context->programBinary(program, binaryFormat, binary, length);
404 }
405 ANGLE_CAPTURE(ProgramBinary, isCallValid, context, program, binaryFormat, binary, length);
406 }
407 }
408
ProgramParameteri(GLuint program,GLenum pname,GLint value)409 void GL_APIENTRY ProgramParameteri(GLuint program, GLenum pname, GLint value)
410 {
411 EVENT("(GLuint program = %u, GLenum pname = %s, GLint value = %d)", program,
412 GLenumToString(GLenumGroup::ProgramParameterPName, pname), value);
413
414 Context *context = GetValidGlobalContext();
415 if (context)
416 {
417 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
418 bool isCallValid = (context->skipValidation() ||
419 ValidateProgramParameteri(context, program, pname, value));
420 if (isCallValid)
421 {
422 context->programParameteri(program, pname, value);
423 }
424 ANGLE_CAPTURE(ProgramParameteri, isCallValid, context, program, pname, value);
425 }
426 }
427
ProgramUniform1d(GLuint program,GLint location,GLdouble v0)428 void GL_APIENTRY ProgramUniform1d(GLuint program, GLint location, GLdouble v0)
429 {
430 EVENT("(GLuint program = %u, GLint location = %d, GLdouble v0 = %f)", program, location, v0);
431
432 Context *context = GetValidGlobalContext();
433 if (context)
434 {
435 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
436 bool isCallValid =
437 (context->skipValidation() || ValidateProgramUniform1d(context, program, location, v0));
438 if (isCallValid)
439 {
440 context->programUniform1d(program, location, v0);
441 }
442 ANGLE_CAPTURE(ProgramUniform1d, isCallValid, context, program, location, v0);
443 }
444 }
445
ProgramUniform1dv(GLuint program,GLint location,GLsizei count,const GLdouble * value)446 void GL_APIENTRY ProgramUniform1dv(GLuint program,
447 GLint location,
448 GLsizei count,
449 const GLdouble *value)
450 {
451 EVENT(
452 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLdouble *value = "
453 "0x%016" PRIxPTR ")",
454 program, location, count, (uintptr_t)value);
455
456 Context *context = GetValidGlobalContext();
457 if (context)
458 {
459 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
460 bool isCallValid = (context->skipValidation() ||
461 ValidateProgramUniform1dv(context, program, location, count, value));
462 if (isCallValid)
463 {
464 context->programUniform1dv(program, location, count, value);
465 }
466 ANGLE_CAPTURE(ProgramUniform1dv, isCallValid, context, program, location, count, value);
467 }
468 }
469
ProgramUniform1f(GLuint program,GLint location,GLfloat v0)470 void GL_APIENTRY ProgramUniform1f(GLuint program, GLint location, GLfloat v0)
471 {
472 EVENT("(GLuint program = %u, GLint location = %d, GLfloat v0 = %f)", program, location, v0);
473
474 Context *context = GetValidGlobalContext();
475 if (context)
476 {
477 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
478 bool isCallValid =
479 (context->skipValidation() || ValidateProgramUniform1f(context, program, location, v0));
480 if (isCallValid)
481 {
482 context->programUniform1f(program, location, v0);
483 }
484 ANGLE_CAPTURE(ProgramUniform1f, isCallValid, context, program, location, v0);
485 }
486 }
487
ProgramUniform1fv(GLuint program,GLint location,GLsizei count,const GLfloat * value)488 void GL_APIENTRY ProgramUniform1fv(GLuint program,
489 GLint location,
490 GLsizei count,
491 const GLfloat *value)
492 {
493 EVENT(
494 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
495 "0x%016" PRIxPTR ")",
496 program, location, count, (uintptr_t)value);
497
498 Context *context = GetValidGlobalContext();
499 if (context)
500 {
501 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
502 bool isCallValid = (context->skipValidation() ||
503 ValidateProgramUniform1fv(context, program, location, count, value));
504 if (isCallValid)
505 {
506 context->programUniform1fv(program, location, count, value);
507 }
508 ANGLE_CAPTURE(ProgramUniform1fv, isCallValid, context, program, location, count, value);
509 }
510 }
511
ProgramUniform1i(GLuint program,GLint location,GLint v0)512 void GL_APIENTRY ProgramUniform1i(GLuint program, GLint location, GLint v0)
513 {
514 EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d)", program, location, v0);
515
516 Context *context = GetValidGlobalContext();
517 if (context)
518 {
519 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
520 bool isCallValid =
521 (context->skipValidation() || ValidateProgramUniform1i(context, program, location, v0));
522 if (isCallValid)
523 {
524 context->programUniform1i(program, location, v0);
525 }
526 ANGLE_CAPTURE(ProgramUniform1i, isCallValid, context, program, location, v0);
527 }
528 }
529
ProgramUniform1iv(GLuint program,GLint location,GLsizei count,const GLint * value)530 void GL_APIENTRY ProgramUniform1iv(GLuint program,
531 GLint location,
532 GLsizei count,
533 const GLint *value)
534 {
535 EVENT(
536 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
537 "0x%016" PRIxPTR ")",
538 program, location, count, (uintptr_t)value);
539
540 Context *context = GetValidGlobalContext();
541 if (context)
542 {
543 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
544 bool isCallValid = (context->skipValidation() ||
545 ValidateProgramUniform1iv(context, program, location, count, value));
546 if (isCallValid)
547 {
548 context->programUniform1iv(program, location, count, value);
549 }
550 ANGLE_CAPTURE(ProgramUniform1iv, isCallValid, context, program, location, count, value);
551 }
552 }
553
ProgramUniform1ui(GLuint program,GLint location,GLuint v0)554 void GL_APIENTRY ProgramUniform1ui(GLuint program, GLint location, GLuint v0)
555 {
556 EVENT("(GLuint program = %u, GLint location = %d, GLuint v0 = %u)", program, location, v0);
557
558 Context *context = GetValidGlobalContext();
559 if (context)
560 {
561 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
562 bool isCallValid = (context->skipValidation() ||
563 ValidateProgramUniform1ui(context, program, location, v0));
564 if (isCallValid)
565 {
566 context->programUniform1ui(program, location, v0);
567 }
568 ANGLE_CAPTURE(ProgramUniform1ui, isCallValid, context, program, location, v0);
569 }
570 }
571
ProgramUniform1uiv(GLuint program,GLint location,GLsizei count,const GLuint * value)572 void GL_APIENTRY ProgramUniform1uiv(GLuint program,
573 GLint location,
574 GLsizei count,
575 const GLuint *value)
576 {
577 EVENT(
578 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
579 "0x%016" PRIxPTR ")",
580 program, location, count, (uintptr_t)value);
581
582 Context *context = GetValidGlobalContext();
583 if (context)
584 {
585 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
586 bool isCallValid = (context->skipValidation() ||
587 ValidateProgramUniform1uiv(context, program, location, count, value));
588 if (isCallValid)
589 {
590 context->programUniform1uiv(program, location, count, value);
591 }
592 ANGLE_CAPTURE(ProgramUniform1uiv, isCallValid, context, program, location, count, value);
593 }
594 }
595
ProgramUniform2d(GLuint program,GLint location,GLdouble v0,GLdouble v1)596 void GL_APIENTRY ProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
597 {
598 EVENT("(GLuint program = %u, GLint location = %d, GLdouble v0 = %f, GLdouble v1 = %f)", program,
599 location, v0, v1);
600
601 Context *context = GetValidGlobalContext();
602 if (context)
603 {
604 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
605 bool isCallValid = (context->skipValidation() ||
606 ValidateProgramUniform2d(context, program, location, v0, v1));
607 if (isCallValid)
608 {
609 context->programUniform2d(program, location, v0, v1);
610 }
611 ANGLE_CAPTURE(ProgramUniform2d, isCallValid, context, program, location, v0, v1);
612 }
613 }
614
ProgramUniform2dv(GLuint program,GLint location,GLsizei count,const GLdouble * value)615 void GL_APIENTRY ProgramUniform2dv(GLuint program,
616 GLint location,
617 GLsizei count,
618 const GLdouble *value)
619 {
620 EVENT(
621 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLdouble *value = "
622 "0x%016" PRIxPTR ")",
623 program, location, count, (uintptr_t)value);
624
625 Context *context = GetValidGlobalContext();
626 if (context)
627 {
628 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
629 bool isCallValid = (context->skipValidation() ||
630 ValidateProgramUniform2dv(context, program, location, count, value));
631 if (isCallValid)
632 {
633 context->programUniform2dv(program, location, count, value);
634 }
635 ANGLE_CAPTURE(ProgramUniform2dv, isCallValid, context, program, location, count, value);
636 }
637 }
638
ProgramUniform2f(GLuint program,GLint location,GLfloat v0,GLfloat v1)639 void GL_APIENTRY ProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
640 {
641 EVENT("(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f)", program,
642 location, v0, v1);
643
644 Context *context = GetValidGlobalContext();
645 if (context)
646 {
647 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
648 bool isCallValid = (context->skipValidation() ||
649 ValidateProgramUniform2f(context, program, location, v0, v1));
650 if (isCallValid)
651 {
652 context->programUniform2f(program, location, v0, v1);
653 }
654 ANGLE_CAPTURE(ProgramUniform2f, isCallValid, context, program, location, v0, v1);
655 }
656 }
657
ProgramUniform2fv(GLuint program,GLint location,GLsizei count,const GLfloat * value)658 void GL_APIENTRY ProgramUniform2fv(GLuint program,
659 GLint location,
660 GLsizei count,
661 const GLfloat *value)
662 {
663 EVENT(
664 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
665 "0x%016" PRIxPTR ")",
666 program, location, count, (uintptr_t)value);
667
668 Context *context = GetValidGlobalContext();
669 if (context)
670 {
671 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
672 bool isCallValid = (context->skipValidation() ||
673 ValidateProgramUniform2fv(context, program, location, count, value));
674 if (isCallValid)
675 {
676 context->programUniform2fv(program, location, count, value);
677 }
678 ANGLE_CAPTURE(ProgramUniform2fv, isCallValid, context, program, location, count, value);
679 }
680 }
681
ProgramUniform2i(GLuint program,GLint location,GLint v0,GLint v1)682 void GL_APIENTRY ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
683 {
684 EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d)", program,
685 location, v0, v1);
686
687 Context *context = GetValidGlobalContext();
688 if (context)
689 {
690 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
691 bool isCallValid = (context->skipValidation() ||
692 ValidateProgramUniform2i(context, program, location, v0, v1));
693 if (isCallValid)
694 {
695 context->programUniform2i(program, location, v0, v1);
696 }
697 ANGLE_CAPTURE(ProgramUniform2i, isCallValid, context, program, location, v0, v1);
698 }
699 }
700
ProgramUniform2iv(GLuint program,GLint location,GLsizei count,const GLint * value)701 void GL_APIENTRY ProgramUniform2iv(GLuint program,
702 GLint location,
703 GLsizei count,
704 const GLint *value)
705 {
706 EVENT(
707 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
708 "0x%016" PRIxPTR ")",
709 program, location, count, (uintptr_t)value);
710
711 Context *context = GetValidGlobalContext();
712 if (context)
713 {
714 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
715 bool isCallValid = (context->skipValidation() ||
716 ValidateProgramUniform2iv(context, program, location, count, value));
717 if (isCallValid)
718 {
719 context->programUniform2iv(program, location, count, value);
720 }
721 ANGLE_CAPTURE(ProgramUniform2iv, isCallValid, context, program, location, count, value);
722 }
723 }
724
ProgramUniform2ui(GLuint program,GLint location,GLuint v0,GLuint v1)725 void GL_APIENTRY ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
726 {
727 EVENT("(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u)", program,
728 location, v0, v1);
729
730 Context *context = GetValidGlobalContext();
731 if (context)
732 {
733 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
734 bool isCallValid = (context->skipValidation() ||
735 ValidateProgramUniform2ui(context, program, location, v0, v1));
736 if (isCallValid)
737 {
738 context->programUniform2ui(program, location, v0, v1);
739 }
740 ANGLE_CAPTURE(ProgramUniform2ui, isCallValid, context, program, location, v0, v1);
741 }
742 }
743
ProgramUniform2uiv(GLuint program,GLint location,GLsizei count,const GLuint * value)744 void GL_APIENTRY ProgramUniform2uiv(GLuint program,
745 GLint location,
746 GLsizei count,
747 const GLuint *value)
748 {
749 EVENT(
750 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
751 "0x%016" PRIxPTR ")",
752 program, location, count, (uintptr_t)value);
753
754 Context *context = GetValidGlobalContext();
755 if (context)
756 {
757 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
758 bool isCallValid = (context->skipValidation() ||
759 ValidateProgramUniform2uiv(context, program, location, count, value));
760 if (isCallValid)
761 {
762 context->programUniform2uiv(program, location, count, value);
763 }
764 ANGLE_CAPTURE(ProgramUniform2uiv, isCallValid, context, program, location, count, value);
765 }
766 }
767
768 void GL_APIENTRY
ProgramUniform3d(GLuint program,GLint location,GLdouble v0,GLdouble v1,GLdouble v2)769 ProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
770 {
771 EVENT(
772 "(GLuint program = %u, GLint location = %d, GLdouble v0 = %f, GLdouble v1 = %f, GLdouble "
773 "v2 = %f)",
774 program, location, v0, v1, v2);
775
776 Context *context = GetValidGlobalContext();
777 if (context)
778 {
779 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
780 bool isCallValid = (context->skipValidation() ||
781 ValidateProgramUniform3d(context, program, location, v0, v1, v2));
782 if (isCallValid)
783 {
784 context->programUniform3d(program, location, v0, v1, v2);
785 }
786 ANGLE_CAPTURE(ProgramUniform3d, isCallValid, context, program, location, v0, v1, v2);
787 }
788 }
789
ProgramUniform3dv(GLuint program,GLint location,GLsizei count,const GLdouble * value)790 void GL_APIENTRY ProgramUniform3dv(GLuint program,
791 GLint location,
792 GLsizei count,
793 const GLdouble *value)
794 {
795 EVENT(
796 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLdouble *value = "
797 "0x%016" PRIxPTR ")",
798 program, location, count, (uintptr_t)value);
799
800 Context *context = GetValidGlobalContext();
801 if (context)
802 {
803 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
804 bool isCallValid = (context->skipValidation() ||
805 ValidateProgramUniform3dv(context, program, location, count, value));
806 if (isCallValid)
807 {
808 context->programUniform3dv(program, location, count, value);
809 }
810 ANGLE_CAPTURE(ProgramUniform3dv, isCallValid, context, program, location, count, value);
811 }
812 }
813
814 void GL_APIENTRY
ProgramUniform3f(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2)815 ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
816 {
817 EVENT(
818 "(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = "
819 "%f)",
820 program, location, v0, v1, v2);
821
822 Context *context = GetValidGlobalContext();
823 if (context)
824 {
825 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
826 bool isCallValid = (context->skipValidation() ||
827 ValidateProgramUniform3f(context, program, location, v0, v1, v2));
828 if (isCallValid)
829 {
830 context->programUniform3f(program, location, v0, v1, v2);
831 }
832 ANGLE_CAPTURE(ProgramUniform3f, isCallValid, context, program, location, v0, v1, v2);
833 }
834 }
835
ProgramUniform3fv(GLuint program,GLint location,GLsizei count,const GLfloat * value)836 void GL_APIENTRY ProgramUniform3fv(GLuint program,
837 GLint location,
838 GLsizei count,
839 const GLfloat *value)
840 {
841 EVENT(
842 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
843 "0x%016" PRIxPTR ")",
844 program, location, count, (uintptr_t)value);
845
846 Context *context = GetValidGlobalContext();
847 if (context)
848 {
849 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
850 bool isCallValid = (context->skipValidation() ||
851 ValidateProgramUniform3fv(context, program, location, count, value));
852 if (isCallValid)
853 {
854 context->programUniform3fv(program, location, count, value);
855 }
856 ANGLE_CAPTURE(ProgramUniform3fv, isCallValid, context, program, location, count, value);
857 }
858 }
859
ProgramUniform3i(GLuint program,GLint location,GLint v0,GLint v1,GLint v2)860 void GL_APIENTRY ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
861 {
862 EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d)",
863 program, location, v0, v1, v2);
864
865 Context *context = GetValidGlobalContext();
866 if (context)
867 {
868 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
869 bool isCallValid = (context->skipValidation() ||
870 ValidateProgramUniform3i(context, program, location, v0, v1, v2));
871 if (isCallValid)
872 {
873 context->programUniform3i(program, location, v0, v1, v2);
874 }
875 ANGLE_CAPTURE(ProgramUniform3i, isCallValid, context, program, location, v0, v1, v2);
876 }
877 }
878
ProgramUniform3iv(GLuint program,GLint location,GLsizei count,const GLint * value)879 void GL_APIENTRY ProgramUniform3iv(GLuint program,
880 GLint location,
881 GLsizei count,
882 const GLint *value)
883 {
884 EVENT(
885 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
886 "0x%016" PRIxPTR ")",
887 program, location, count, (uintptr_t)value);
888
889 Context *context = GetValidGlobalContext();
890 if (context)
891 {
892 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
893 bool isCallValid = (context->skipValidation() ||
894 ValidateProgramUniform3iv(context, program, location, count, value));
895 if (isCallValid)
896 {
897 context->programUniform3iv(program, location, count, value);
898 }
899 ANGLE_CAPTURE(ProgramUniform3iv, isCallValid, context, program, location, count, value);
900 }
901 }
902
ProgramUniform3ui(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2)903 void GL_APIENTRY ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
904 {
905 EVENT(
906 "(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = "
907 "%u)",
908 program, location, v0, v1, v2);
909
910 Context *context = GetValidGlobalContext();
911 if (context)
912 {
913 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
914 bool isCallValid = (context->skipValidation() ||
915 ValidateProgramUniform3ui(context, program, location, v0, v1, v2));
916 if (isCallValid)
917 {
918 context->programUniform3ui(program, location, v0, v1, v2);
919 }
920 ANGLE_CAPTURE(ProgramUniform3ui, isCallValid, context, program, location, v0, v1, v2);
921 }
922 }
923
ProgramUniform3uiv(GLuint program,GLint location,GLsizei count,const GLuint * value)924 void GL_APIENTRY ProgramUniform3uiv(GLuint program,
925 GLint location,
926 GLsizei count,
927 const GLuint *value)
928 {
929 EVENT(
930 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
931 "0x%016" PRIxPTR ")",
932 program, location, count, (uintptr_t)value);
933
934 Context *context = GetValidGlobalContext();
935 if (context)
936 {
937 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
938 bool isCallValid = (context->skipValidation() ||
939 ValidateProgramUniform3uiv(context, program, location, count, value));
940 if (isCallValid)
941 {
942 context->programUniform3uiv(program, location, count, value);
943 }
944 ANGLE_CAPTURE(ProgramUniform3uiv, isCallValid, context, program, location, count, value);
945 }
946 }
947
948 void GL_APIENTRY
ProgramUniform4d(GLuint program,GLint location,GLdouble v0,GLdouble v1,GLdouble v2,GLdouble v3)949 ProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
950 {
951 EVENT(
952 "(GLuint program = %u, GLint location = %d, GLdouble v0 = %f, GLdouble v1 = %f, GLdouble "
953 "v2 = %f, GLdouble v3 = %f)",
954 program, location, v0, v1, v2, v3);
955
956 Context *context = GetValidGlobalContext();
957 if (context)
958 {
959 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
960 bool isCallValid = (context->skipValidation() ||
961 ValidateProgramUniform4d(context, program, location, v0, v1, v2, v3));
962 if (isCallValid)
963 {
964 context->programUniform4d(program, location, v0, v1, v2, v3);
965 }
966 ANGLE_CAPTURE(ProgramUniform4d, isCallValid, context, program, location, v0, v1, v2, v3);
967 }
968 }
969
ProgramUniform4dv(GLuint program,GLint location,GLsizei count,const GLdouble * value)970 void GL_APIENTRY ProgramUniform4dv(GLuint program,
971 GLint location,
972 GLsizei count,
973 const GLdouble *value)
974 {
975 EVENT(
976 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLdouble *value = "
977 "0x%016" PRIxPTR ")",
978 program, location, count, (uintptr_t)value);
979
980 Context *context = GetValidGlobalContext();
981 if (context)
982 {
983 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
984 bool isCallValid = (context->skipValidation() ||
985 ValidateProgramUniform4dv(context, program, location, count, value));
986 if (isCallValid)
987 {
988 context->programUniform4dv(program, location, count, value);
989 }
990 ANGLE_CAPTURE(ProgramUniform4dv, isCallValid, context, program, location, count, value);
991 }
992 }
993
994 void GL_APIENTRY
ProgramUniform4f(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)995 ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
996 {
997 EVENT(
998 "(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = "
999 "%f, GLfloat v3 = %f)",
1000 program, location, v0, v1, v2, v3);
1001
1002 Context *context = GetValidGlobalContext();
1003 if (context)
1004 {
1005 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1006 bool isCallValid = (context->skipValidation() ||
1007 ValidateProgramUniform4f(context, program, location, v0, v1, v2, v3));
1008 if (isCallValid)
1009 {
1010 context->programUniform4f(program, location, v0, v1, v2, v3);
1011 }
1012 ANGLE_CAPTURE(ProgramUniform4f, isCallValid, context, program, location, v0, v1, v2, v3);
1013 }
1014 }
1015
ProgramUniform4fv(GLuint program,GLint location,GLsizei count,const GLfloat * value)1016 void GL_APIENTRY ProgramUniform4fv(GLuint program,
1017 GLint location,
1018 GLsizei count,
1019 const GLfloat *value)
1020 {
1021 EVENT(
1022 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
1023 "0x%016" PRIxPTR ")",
1024 program, location, count, (uintptr_t)value);
1025
1026 Context *context = GetValidGlobalContext();
1027 if (context)
1028 {
1029 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1030 bool isCallValid = (context->skipValidation() ||
1031 ValidateProgramUniform4fv(context, program, location, count, value));
1032 if (isCallValid)
1033 {
1034 context->programUniform4fv(program, location, count, value);
1035 }
1036 ANGLE_CAPTURE(ProgramUniform4fv, isCallValid, context, program, location, count, value);
1037 }
1038 }
1039
1040 void GL_APIENTRY
ProgramUniform4i(GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3)1041 ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
1042 {
1043 EVENT(
1044 "(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d, "
1045 "GLint v3 = %d)",
1046 program, location, v0, v1, v2, v3);
1047
1048 Context *context = GetValidGlobalContext();
1049 if (context)
1050 {
1051 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1052 bool isCallValid = (context->skipValidation() ||
1053 ValidateProgramUniform4i(context, program, location, v0, v1, v2, v3));
1054 if (isCallValid)
1055 {
1056 context->programUniform4i(program, location, v0, v1, v2, v3);
1057 }
1058 ANGLE_CAPTURE(ProgramUniform4i, isCallValid, context, program, location, v0, v1, v2, v3);
1059 }
1060 }
1061
ProgramUniform4iv(GLuint program,GLint location,GLsizei count,const GLint * value)1062 void GL_APIENTRY ProgramUniform4iv(GLuint program,
1063 GLint location,
1064 GLsizei count,
1065 const GLint *value)
1066 {
1067 EVENT(
1068 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
1069 "0x%016" PRIxPTR ")",
1070 program, location, count, (uintptr_t)value);
1071
1072 Context *context = GetValidGlobalContext();
1073 if (context)
1074 {
1075 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1076 bool isCallValid = (context->skipValidation() ||
1077 ValidateProgramUniform4iv(context, program, location, count, value));
1078 if (isCallValid)
1079 {
1080 context->programUniform4iv(program, location, count, value);
1081 }
1082 ANGLE_CAPTURE(ProgramUniform4iv, isCallValid, context, program, location, count, value);
1083 }
1084 }
1085
1086 void GL_APIENTRY
ProgramUniform4ui(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)1087 ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
1088 {
1089 EVENT(
1090 "(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = "
1091 "%u, GLuint v3 = %u)",
1092 program, location, v0, v1, v2, v3);
1093
1094 Context *context = GetValidGlobalContext();
1095 if (context)
1096 {
1097 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1098 bool isCallValid = (context->skipValidation() ||
1099 ValidateProgramUniform4ui(context, program, location, v0, v1, v2, v3));
1100 if (isCallValid)
1101 {
1102 context->programUniform4ui(program, location, v0, v1, v2, v3);
1103 }
1104 ANGLE_CAPTURE(ProgramUniform4ui, isCallValid, context, program, location, v0, v1, v2, v3);
1105 }
1106 }
1107
ProgramUniform4uiv(GLuint program,GLint location,GLsizei count,const GLuint * value)1108 void GL_APIENTRY ProgramUniform4uiv(GLuint program,
1109 GLint location,
1110 GLsizei count,
1111 const GLuint *value)
1112 {
1113 EVENT(
1114 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
1115 "0x%016" PRIxPTR ")",
1116 program, location, count, (uintptr_t)value);
1117
1118 Context *context = GetValidGlobalContext();
1119 if (context)
1120 {
1121 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1122 bool isCallValid = (context->skipValidation() ||
1123 ValidateProgramUniform4uiv(context, program, location, count, value));
1124 if (isCallValid)
1125 {
1126 context->programUniform4uiv(program, location, count, value);
1127 }
1128 ANGLE_CAPTURE(ProgramUniform4uiv, isCallValid, context, program, location, count, value);
1129 }
1130 }
1131
ProgramUniformMatrix2dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)1132 void GL_APIENTRY ProgramUniformMatrix2dv(GLuint program,
1133 GLint location,
1134 GLsizei count,
1135 GLboolean transpose,
1136 const GLdouble *value)
1137 {
1138 EVENT(
1139 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1140 "const GLdouble *value = 0x%016" PRIxPTR ")",
1141 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1142
1143 Context *context = GetValidGlobalContext();
1144 if (context)
1145 {
1146 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1147 bool isCallValid =
1148 (context->skipValidation() ||
1149 ValidateProgramUniformMatrix2dv(context, program, location, count, transpose, value));
1150 if (isCallValid)
1151 {
1152 context->programUniformMatrix2dv(program, location, count, transpose, value);
1153 }
1154 ANGLE_CAPTURE(ProgramUniformMatrix2dv, isCallValid, context, program, location, count,
1155 transpose, value);
1156 }
1157 }
1158
ProgramUniformMatrix2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1159 void GL_APIENTRY ProgramUniformMatrix2fv(GLuint program,
1160 GLint location,
1161 GLsizei count,
1162 GLboolean transpose,
1163 const GLfloat *value)
1164 {
1165 EVENT(
1166 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1167 "const GLfloat *value = 0x%016" PRIxPTR ")",
1168 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1169
1170 Context *context = GetValidGlobalContext();
1171 if (context)
1172 {
1173 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1174 bool isCallValid =
1175 (context->skipValidation() ||
1176 ValidateProgramUniformMatrix2fv(context, program, location, count, transpose, value));
1177 if (isCallValid)
1178 {
1179 context->programUniformMatrix2fv(program, location, count, transpose, value);
1180 }
1181 ANGLE_CAPTURE(ProgramUniformMatrix2fv, isCallValid, context, program, location, count,
1182 transpose, value);
1183 }
1184 }
1185
ProgramUniformMatrix2x3dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)1186 void GL_APIENTRY ProgramUniformMatrix2x3dv(GLuint program,
1187 GLint location,
1188 GLsizei count,
1189 GLboolean transpose,
1190 const GLdouble *value)
1191 {
1192 EVENT(
1193 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1194 "const GLdouble *value = 0x%016" PRIxPTR ")",
1195 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1196
1197 Context *context = GetValidGlobalContext();
1198 if (context)
1199 {
1200 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1201 bool isCallValid =
1202 (context->skipValidation() || ValidateProgramUniformMatrix2x3dv(
1203 context, program, location, count, transpose, value));
1204 if (isCallValid)
1205 {
1206 context->programUniformMatrix2x3dv(program, location, count, transpose, value);
1207 }
1208 ANGLE_CAPTURE(ProgramUniformMatrix2x3dv, isCallValid, context, program, location, count,
1209 transpose, value);
1210 }
1211 }
1212
ProgramUniformMatrix2x3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1213 void GL_APIENTRY ProgramUniformMatrix2x3fv(GLuint program,
1214 GLint location,
1215 GLsizei count,
1216 GLboolean transpose,
1217 const GLfloat *value)
1218 {
1219 EVENT(
1220 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1221 "const GLfloat *value = 0x%016" PRIxPTR ")",
1222 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1223
1224 Context *context = GetValidGlobalContext();
1225 if (context)
1226 {
1227 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1228 bool isCallValid =
1229 (context->skipValidation() || ValidateProgramUniformMatrix2x3fv(
1230 context, program, location, count, transpose, value));
1231 if (isCallValid)
1232 {
1233 context->programUniformMatrix2x3fv(program, location, count, transpose, value);
1234 }
1235 ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, isCallValid, context, program, location, count,
1236 transpose, value);
1237 }
1238 }
1239
ProgramUniformMatrix2x4dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)1240 void GL_APIENTRY ProgramUniformMatrix2x4dv(GLuint program,
1241 GLint location,
1242 GLsizei count,
1243 GLboolean transpose,
1244 const GLdouble *value)
1245 {
1246 EVENT(
1247 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1248 "const GLdouble *value = 0x%016" PRIxPTR ")",
1249 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1250
1251 Context *context = GetValidGlobalContext();
1252 if (context)
1253 {
1254 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1255 bool isCallValid =
1256 (context->skipValidation() || ValidateProgramUniformMatrix2x4dv(
1257 context, program, location, count, transpose, value));
1258 if (isCallValid)
1259 {
1260 context->programUniformMatrix2x4dv(program, location, count, transpose, value);
1261 }
1262 ANGLE_CAPTURE(ProgramUniformMatrix2x4dv, isCallValid, context, program, location, count,
1263 transpose, value);
1264 }
1265 }
1266
ProgramUniformMatrix2x4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1267 void GL_APIENTRY ProgramUniformMatrix2x4fv(GLuint program,
1268 GLint location,
1269 GLsizei count,
1270 GLboolean transpose,
1271 const GLfloat *value)
1272 {
1273 EVENT(
1274 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1275 "const GLfloat *value = 0x%016" PRIxPTR ")",
1276 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1277
1278 Context *context = GetValidGlobalContext();
1279 if (context)
1280 {
1281 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1282 bool isCallValid =
1283 (context->skipValidation() || ValidateProgramUniformMatrix2x4fv(
1284 context, program, location, count, transpose, value));
1285 if (isCallValid)
1286 {
1287 context->programUniformMatrix2x4fv(program, location, count, transpose, value);
1288 }
1289 ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, isCallValid, context, program, location, count,
1290 transpose, value);
1291 }
1292 }
1293
ProgramUniformMatrix3dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)1294 void GL_APIENTRY ProgramUniformMatrix3dv(GLuint program,
1295 GLint location,
1296 GLsizei count,
1297 GLboolean transpose,
1298 const GLdouble *value)
1299 {
1300 EVENT(
1301 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1302 "const GLdouble *value = 0x%016" PRIxPTR ")",
1303 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1304
1305 Context *context = GetValidGlobalContext();
1306 if (context)
1307 {
1308 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1309 bool isCallValid =
1310 (context->skipValidation() ||
1311 ValidateProgramUniformMatrix3dv(context, program, location, count, transpose, value));
1312 if (isCallValid)
1313 {
1314 context->programUniformMatrix3dv(program, location, count, transpose, value);
1315 }
1316 ANGLE_CAPTURE(ProgramUniformMatrix3dv, isCallValid, context, program, location, count,
1317 transpose, value);
1318 }
1319 }
1320
ProgramUniformMatrix3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1321 void GL_APIENTRY ProgramUniformMatrix3fv(GLuint program,
1322 GLint location,
1323 GLsizei count,
1324 GLboolean transpose,
1325 const GLfloat *value)
1326 {
1327 EVENT(
1328 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1329 "const GLfloat *value = 0x%016" PRIxPTR ")",
1330 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1331
1332 Context *context = GetValidGlobalContext();
1333 if (context)
1334 {
1335 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1336 bool isCallValid =
1337 (context->skipValidation() ||
1338 ValidateProgramUniformMatrix3fv(context, program, location, count, transpose, value));
1339 if (isCallValid)
1340 {
1341 context->programUniformMatrix3fv(program, location, count, transpose, value);
1342 }
1343 ANGLE_CAPTURE(ProgramUniformMatrix3fv, isCallValid, context, program, location, count,
1344 transpose, value);
1345 }
1346 }
1347
ProgramUniformMatrix3x2dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)1348 void GL_APIENTRY ProgramUniformMatrix3x2dv(GLuint program,
1349 GLint location,
1350 GLsizei count,
1351 GLboolean transpose,
1352 const GLdouble *value)
1353 {
1354 EVENT(
1355 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1356 "const GLdouble *value = 0x%016" PRIxPTR ")",
1357 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1358
1359 Context *context = GetValidGlobalContext();
1360 if (context)
1361 {
1362 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1363 bool isCallValid =
1364 (context->skipValidation() || ValidateProgramUniformMatrix3x2dv(
1365 context, program, location, count, transpose, value));
1366 if (isCallValid)
1367 {
1368 context->programUniformMatrix3x2dv(program, location, count, transpose, value);
1369 }
1370 ANGLE_CAPTURE(ProgramUniformMatrix3x2dv, isCallValid, context, program, location, count,
1371 transpose, value);
1372 }
1373 }
1374
ProgramUniformMatrix3x2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1375 void GL_APIENTRY ProgramUniformMatrix3x2fv(GLuint program,
1376 GLint location,
1377 GLsizei count,
1378 GLboolean transpose,
1379 const GLfloat *value)
1380 {
1381 EVENT(
1382 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1383 "const GLfloat *value = 0x%016" PRIxPTR ")",
1384 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1385
1386 Context *context = GetValidGlobalContext();
1387 if (context)
1388 {
1389 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1390 bool isCallValid =
1391 (context->skipValidation() || ValidateProgramUniformMatrix3x2fv(
1392 context, program, location, count, transpose, value));
1393 if (isCallValid)
1394 {
1395 context->programUniformMatrix3x2fv(program, location, count, transpose, value);
1396 }
1397 ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, isCallValid, context, program, location, count,
1398 transpose, value);
1399 }
1400 }
1401
ProgramUniformMatrix3x4dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)1402 void GL_APIENTRY ProgramUniformMatrix3x4dv(GLuint program,
1403 GLint location,
1404 GLsizei count,
1405 GLboolean transpose,
1406 const GLdouble *value)
1407 {
1408 EVENT(
1409 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1410 "const GLdouble *value = 0x%016" PRIxPTR ")",
1411 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1412
1413 Context *context = GetValidGlobalContext();
1414 if (context)
1415 {
1416 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1417 bool isCallValid =
1418 (context->skipValidation() || ValidateProgramUniformMatrix3x4dv(
1419 context, program, location, count, transpose, value));
1420 if (isCallValid)
1421 {
1422 context->programUniformMatrix3x4dv(program, location, count, transpose, value);
1423 }
1424 ANGLE_CAPTURE(ProgramUniformMatrix3x4dv, isCallValid, context, program, location, count,
1425 transpose, value);
1426 }
1427 }
1428
ProgramUniformMatrix3x4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1429 void GL_APIENTRY ProgramUniformMatrix3x4fv(GLuint program,
1430 GLint location,
1431 GLsizei count,
1432 GLboolean transpose,
1433 const GLfloat *value)
1434 {
1435 EVENT(
1436 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1437 "const GLfloat *value = 0x%016" PRIxPTR ")",
1438 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1439
1440 Context *context = GetValidGlobalContext();
1441 if (context)
1442 {
1443 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1444 bool isCallValid =
1445 (context->skipValidation() || ValidateProgramUniformMatrix3x4fv(
1446 context, program, location, count, transpose, value));
1447 if (isCallValid)
1448 {
1449 context->programUniformMatrix3x4fv(program, location, count, transpose, value);
1450 }
1451 ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, isCallValid, context, program, location, count,
1452 transpose, value);
1453 }
1454 }
1455
ProgramUniformMatrix4dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)1456 void GL_APIENTRY ProgramUniformMatrix4dv(GLuint program,
1457 GLint location,
1458 GLsizei count,
1459 GLboolean transpose,
1460 const GLdouble *value)
1461 {
1462 EVENT(
1463 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1464 "const GLdouble *value = 0x%016" PRIxPTR ")",
1465 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1466
1467 Context *context = GetValidGlobalContext();
1468 if (context)
1469 {
1470 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1471 bool isCallValid =
1472 (context->skipValidation() ||
1473 ValidateProgramUniformMatrix4dv(context, program, location, count, transpose, value));
1474 if (isCallValid)
1475 {
1476 context->programUniformMatrix4dv(program, location, count, transpose, value);
1477 }
1478 ANGLE_CAPTURE(ProgramUniformMatrix4dv, isCallValid, context, program, location, count,
1479 transpose, value);
1480 }
1481 }
1482
ProgramUniformMatrix4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1483 void GL_APIENTRY ProgramUniformMatrix4fv(GLuint program,
1484 GLint location,
1485 GLsizei count,
1486 GLboolean transpose,
1487 const GLfloat *value)
1488 {
1489 EVENT(
1490 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1491 "const GLfloat *value = 0x%016" PRIxPTR ")",
1492 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1493
1494 Context *context = GetValidGlobalContext();
1495 if (context)
1496 {
1497 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1498 bool isCallValid =
1499 (context->skipValidation() ||
1500 ValidateProgramUniformMatrix4fv(context, program, location, count, transpose, value));
1501 if (isCallValid)
1502 {
1503 context->programUniformMatrix4fv(program, location, count, transpose, value);
1504 }
1505 ANGLE_CAPTURE(ProgramUniformMatrix4fv, isCallValid, context, program, location, count,
1506 transpose, value);
1507 }
1508 }
1509
ProgramUniformMatrix4x2dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)1510 void GL_APIENTRY ProgramUniformMatrix4x2dv(GLuint program,
1511 GLint location,
1512 GLsizei count,
1513 GLboolean transpose,
1514 const GLdouble *value)
1515 {
1516 EVENT(
1517 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1518 "const GLdouble *value = 0x%016" PRIxPTR ")",
1519 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1520
1521 Context *context = GetValidGlobalContext();
1522 if (context)
1523 {
1524 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1525 bool isCallValid =
1526 (context->skipValidation() || ValidateProgramUniformMatrix4x2dv(
1527 context, program, location, count, transpose, value));
1528 if (isCallValid)
1529 {
1530 context->programUniformMatrix4x2dv(program, location, count, transpose, value);
1531 }
1532 ANGLE_CAPTURE(ProgramUniformMatrix4x2dv, isCallValid, context, program, location, count,
1533 transpose, value);
1534 }
1535 }
1536
ProgramUniformMatrix4x2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1537 void GL_APIENTRY ProgramUniformMatrix4x2fv(GLuint program,
1538 GLint location,
1539 GLsizei count,
1540 GLboolean transpose,
1541 const GLfloat *value)
1542 {
1543 EVENT(
1544 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1545 "const GLfloat *value = 0x%016" PRIxPTR ")",
1546 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1547
1548 Context *context = GetValidGlobalContext();
1549 if (context)
1550 {
1551 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1552 bool isCallValid =
1553 (context->skipValidation() || ValidateProgramUniformMatrix4x2fv(
1554 context, program, location, count, transpose, value));
1555 if (isCallValid)
1556 {
1557 context->programUniformMatrix4x2fv(program, location, count, transpose, value);
1558 }
1559 ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, isCallValid, context, program, location, count,
1560 transpose, value);
1561 }
1562 }
1563
ProgramUniformMatrix4x3dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble * value)1564 void GL_APIENTRY ProgramUniformMatrix4x3dv(GLuint program,
1565 GLint location,
1566 GLsizei count,
1567 GLboolean transpose,
1568 const GLdouble *value)
1569 {
1570 EVENT(
1571 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1572 "const GLdouble *value = 0x%016" PRIxPTR ")",
1573 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1574
1575 Context *context = GetValidGlobalContext();
1576 if (context)
1577 {
1578 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1579 bool isCallValid =
1580 (context->skipValidation() || ValidateProgramUniformMatrix4x3dv(
1581 context, program, location, count, transpose, value));
1582 if (isCallValid)
1583 {
1584 context->programUniformMatrix4x3dv(program, location, count, transpose, value);
1585 }
1586 ANGLE_CAPTURE(ProgramUniformMatrix4x3dv, isCallValid, context, program, location, count,
1587 transpose, value);
1588 }
1589 }
1590
ProgramUniformMatrix4x3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1591 void GL_APIENTRY ProgramUniformMatrix4x3fv(GLuint program,
1592 GLint location,
1593 GLsizei count,
1594 GLboolean transpose,
1595 const GLfloat *value)
1596 {
1597 EVENT(
1598 "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, "
1599 "const GLfloat *value = 0x%016" PRIxPTR ")",
1600 program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1601
1602 Context *context = GetValidGlobalContext();
1603 if (context)
1604 {
1605 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1606 bool isCallValid =
1607 (context->skipValidation() || ValidateProgramUniformMatrix4x3fv(
1608 context, program, location, count, transpose, value));
1609 if (isCallValid)
1610 {
1611 context->programUniformMatrix4x3fv(program, location, count, transpose, value);
1612 }
1613 ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, isCallValid, context, program, location, count,
1614 transpose, value);
1615 }
1616 }
1617
ReleaseShaderCompiler()1618 void GL_APIENTRY ReleaseShaderCompiler()
1619 {
1620 EVENT("()");
1621
1622 Context *context = GetValidGlobalContext();
1623 if (context)
1624 {
1625 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1626 bool isCallValid = (context->skipValidation() || ValidateReleaseShaderCompiler(context));
1627 if (isCallValid)
1628 {
1629 context->releaseShaderCompiler();
1630 }
1631 ANGLE_CAPTURE(ReleaseShaderCompiler, isCallValid, context);
1632 }
1633 }
1634
ScissorArrayv(GLuint first,GLsizei count,const GLint * v)1635 void GL_APIENTRY ScissorArrayv(GLuint first, GLsizei count, const GLint *v)
1636 {
1637 EVENT("(GLuint first = %u, GLsizei count = %d, const GLint *v = 0x%016" PRIxPTR ")", first,
1638 count, (uintptr_t)v);
1639
1640 Context *context = GetValidGlobalContext();
1641 if (context)
1642 {
1643 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1644 bool isCallValid =
1645 (context->skipValidation() || ValidateScissorArrayv(context, first, count, v));
1646 if (isCallValid)
1647 {
1648 context->scissorArrayv(first, count, v);
1649 }
1650 ANGLE_CAPTURE(ScissorArrayv, isCallValid, context, first, count, v);
1651 }
1652 }
1653
1654 void GL_APIENTRY
ScissorIndexed(GLuint index,GLint left,GLint bottom,GLsizei width,GLsizei height)1655 ScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
1656 {
1657 EVENT(
1658 "(GLuint index = %u, GLint left = %d, GLint bottom = %d, GLsizei width = %d, GLsizei "
1659 "height = %d)",
1660 index, left, bottom, width, height);
1661
1662 Context *context = GetValidGlobalContext();
1663 if (context)
1664 {
1665 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1666 bool isCallValid = (context->skipValidation() ||
1667 ValidateScissorIndexed(context, index, left, bottom, width, height));
1668 if (isCallValid)
1669 {
1670 context->scissorIndexed(index, left, bottom, width, height);
1671 }
1672 ANGLE_CAPTURE(ScissorIndexed, isCallValid, context, index, left, bottom, width, height);
1673 }
1674 }
1675
ScissorIndexedv(GLuint index,const GLint * v)1676 void GL_APIENTRY ScissorIndexedv(GLuint index, const GLint *v)
1677 {
1678 EVENT("(GLuint index = %u, const GLint *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
1679
1680 Context *context = GetValidGlobalContext();
1681 if (context)
1682 {
1683 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1684 bool isCallValid =
1685 (context->skipValidation() || ValidateScissorIndexedv(context, index, v));
1686 if (isCallValid)
1687 {
1688 context->scissorIndexedv(index, v);
1689 }
1690 ANGLE_CAPTURE(ScissorIndexedv, isCallValid, context, index, v);
1691 }
1692 }
1693
ShaderBinary(GLsizei count,const GLuint * shaders,GLenum binaryformat,const void * binary,GLsizei length)1694 void GL_APIENTRY ShaderBinary(GLsizei count,
1695 const GLuint *shaders,
1696 GLenum binaryformat,
1697 const void *binary,
1698 GLsizei length)
1699 {
1700 EVENT("(GLsizei count = %d, const GLuint *shaders = 0x%016" PRIxPTR
1701 ", GLenum binaryformat = %s, const void *binary = 0x%016" PRIxPTR
1702 ", GLsizei length = %d)",
1703 count, (uintptr_t)shaders, GLenumToString(GLenumGroup::DefaultGroup, binaryformat),
1704 (uintptr_t)binary, length);
1705
1706 Context *context = GetValidGlobalContext();
1707 if (context)
1708 {
1709 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1710 bool isCallValid =
1711 (context->skipValidation() ||
1712 ValidateShaderBinary(context, count, shaders, binaryformat, binary, length));
1713 if (isCallValid)
1714 {
1715 context->shaderBinary(count, shaders, binaryformat, binary, length);
1716 }
1717 ANGLE_CAPTURE(ShaderBinary, isCallValid, context, count, shaders, binaryformat, binary,
1718 length);
1719 }
1720 }
1721
UseProgramStages(GLuint pipeline,GLbitfield stages,GLuint program)1722 void GL_APIENTRY UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
1723 {
1724 EVENT("(GLuint pipeline = %u, GLbitfield stages = %s, GLuint program = %u)", pipeline,
1725 GLbitfieldToString(GLenumGroup::UseProgramStageMask, stages).c_str(), program);
1726
1727 Context *context = GetValidGlobalContext();
1728 if (context)
1729 {
1730 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1731 bool isCallValid = (context->skipValidation() ||
1732 ValidateUseProgramStages(context, pipeline, stages, program));
1733 if (isCallValid)
1734 {
1735 context->useProgramStages(pipeline, stages, program);
1736 }
1737 ANGLE_CAPTURE(UseProgramStages, isCallValid, context, pipeline, stages, program);
1738 }
1739 }
1740
ValidateProgramPipeline(GLuint pipeline)1741 void GL_APIENTRY ValidateProgramPipeline(GLuint pipeline)
1742 {
1743 EVENT("(GLuint pipeline = %u)", pipeline);
1744
1745 Context *context = GetValidGlobalContext();
1746 if (context)
1747 {
1748 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1749 bool isCallValid =
1750 (context->skipValidation() || ValidateValidateProgramPipeline(context, pipeline));
1751 if (isCallValid)
1752 {
1753 context->validateProgramPipeline(pipeline);
1754 }
1755 ANGLE_CAPTURE(ValidateProgramPipeline, isCallValid, context, pipeline);
1756 }
1757 }
1758
VertexAttribL1d(GLuint index,GLdouble x)1759 void GL_APIENTRY VertexAttribL1d(GLuint index, GLdouble x)
1760 {
1761 EVENT("(GLuint index = %u, GLdouble x = %f)", index, x);
1762
1763 Context *context = GetValidGlobalContext();
1764 if (context)
1765 {
1766 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1767 bool isCallValid =
1768 (context->skipValidation() || ValidateVertexAttribL1d(context, index, x));
1769 if (isCallValid)
1770 {
1771 context->vertexAttribL1d(index, x);
1772 }
1773 ANGLE_CAPTURE(VertexAttribL1d, isCallValid, context, index, x);
1774 }
1775 }
1776
VertexAttribL1dv(GLuint index,const GLdouble * v)1777 void GL_APIENTRY VertexAttribL1dv(GLuint index, const GLdouble *v)
1778 {
1779 EVENT("(GLuint index = %u, const GLdouble *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
1780
1781 Context *context = GetValidGlobalContext();
1782 if (context)
1783 {
1784 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1785 bool isCallValid =
1786 (context->skipValidation() || ValidateVertexAttribL1dv(context, index, v));
1787 if (isCallValid)
1788 {
1789 context->vertexAttribL1dv(index, v);
1790 }
1791 ANGLE_CAPTURE(VertexAttribL1dv, isCallValid, context, index, v);
1792 }
1793 }
1794
VertexAttribL2d(GLuint index,GLdouble x,GLdouble y)1795 void GL_APIENTRY VertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
1796 {
1797 EVENT("(GLuint index = %u, GLdouble x = %f, GLdouble y = %f)", index, x, y);
1798
1799 Context *context = GetValidGlobalContext();
1800 if (context)
1801 {
1802 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1803 bool isCallValid =
1804 (context->skipValidation() || ValidateVertexAttribL2d(context, index, x, y));
1805 if (isCallValid)
1806 {
1807 context->vertexAttribL2d(index, x, y);
1808 }
1809 ANGLE_CAPTURE(VertexAttribL2d, isCallValid, context, index, x, y);
1810 }
1811 }
1812
VertexAttribL2dv(GLuint index,const GLdouble * v)1813 void GL_APIENTRY VertexAttribL2dv(GLuint index, const GLdouble *v)
1814 {
1815 EVENT("(GLuint index = %u, const GLdouble *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
1816
1817 Context *context = GetValidGlobalContext();
1818 if (context)
1819 {
1820 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1821 bool isCallValid =
1822 (context->skipValidation() || ValidateVertexAttribL2dv(context, index, v));
1823 if (isCallValid)
1824 {
1825 context->vertexAttribL2dv(index, v);
1826 }
1827 ANGLE_CAPTURE(VertexAttribL2dv, isCallValid, context, index, v);
1828 }
1829 }
1830
VertexAttribL3d(GLuint index,GLdouble x,GLdouble y,GLdouble z)1831 void GL_APIENTRY VertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
1832 {
1833 EVENT("(GLuint index = %u, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f)", index, x, y, z);
1834
1835 Context *context = GetValidGlobalContext();
1836 if (context)
1837 {
1838 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1839 bool isCallValid =
1840 (context->skipValidation() || ValidateVertexAttribL3d(context, index, x, y, z));
1841 if (isCallValid)
1842 {
1843 context->vertexAttribL3d(index, x, y, z);
1844 }
1845 ANGLE_CAPTURE(VertexAttribL3d, isCallValid, context, index, x, y, z);
1846 }
1847 }
1848
VertexAttribL3dv(GLuint index,const GLdouble * v)1849 void GL_APIENTRY VertexAttribL3dv(GLuint index, const GLdouble *v)
1850 {
1851 EVENT("(GLuint index = %u, const GLdouble *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
1852
1853 Context *context = GetValidGlobalContext();
1854 if (context)
1855 {
1856 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1857 bool isCallValid =
1858 (context->skipValidation() || ValidateVertexAttribL3dv(context, index, v));
1859 if (isCallValid)
1860 {
1861 context->vertexAttribL3dv(index, v);
1862 }
1863 ANGLE_CAPTURE(VertexAttribL3dv, isCallValid, context, index, v);
1864 }
1865 }
1866
VertexAttribL4d(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)1867 void GL_APIENTRY VertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1868 {
1869 EVENT("(GLuint index = %u, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f, GLdouble w = %f)",
1870 index, x, y, z, w);
1871
1872 Context *context = GetValidGlobalContext();
1873 if (context)
1874 {
1875 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1876 bool isCallValid =
1877 (context->skipValidation() || ValidateVertexAttribL4d(context, index, x, y, z, w));
1878 if (isCallValid)
1879 {
1880 context->vertexAttribL4d(index, x, y, z, w);
1881 }
1882 ANGLE_CAPTURE(VertexAttribL4d, isCallValid, context, index, x, y, z, w);
1883 }
1884 }
1885
VertexAttribL4dv(GLuint index,const GLdouble * v)1886 void GL_APIENTRY VertexAttribL4dv(GLuint index, const GLdouble *v)
1887 {
1888 EVENT("(GLuint index = %u, const GLdouble *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
1889
1890 Context *context = GetValidGlobalContext();
1891 if (context)
1892 {
1893 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1894 bool isCallValid =
1895 (context->skipValidation() || ValidateVertexAttribL4dv(context, index, v));
1896 if (isCallValid)
1897 {
1898 context->vertexAttribL4dv(index, v);
1899 }
1900 ANGLE_CAPTURE(VertexAttribL4dv, isCallValid, context, index, v);
1901 }
1902 }
1903
1904 void GL_APIENTRY
VertexAttribLPointer(GLuint index,GLint size,GLenum type,GLsizei stride,const void * pointer)1905 VertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
1906 {
1907 EVENT(
1908 "(GLuint index = %u, GLint size = %d, GLenum type = %s, GLsizei stride = %d, const void "
1909 "*pointer = 0x%016" PRIxPTR ")",
1910 index, size, GLenumToString(GLenumGroup::VertexAttribPointerType, type), stride,
1911 (uintptr_t)pointer);
1912
1913 Context *context = GetValidGlobalContext();
1914 if (context)
1915 {
1916 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1917 bool isCallValid =
1918 (context->skipValidation() ||
1919 ValidateVertexAttribLPointer(context, index, size, type, stride, pointer));
1920 if (isCallValid)
1921 {
1922 context->vertexAttribLPointer(index, size, type, stride, pointer);
1923 }
1924 ANGLE_CAPTURE(VertexAttribLPointer, isCallValid, context, index, size, type, stride,
1925 pointer);
1926 }
1927 }
1928
ViewportArrayv(GLuint first,GLsizei count,const GLfloat * v)1929 void GL_APIENTRY ViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
1930 {
1931 EVENT("(GLuint first = %u, GLsizei count = %d, const GLfloat *v = 0x%016" PRIxPTR ")", first,
1932 count, (uintptr_t)v);
1933
1934 Context *context = GetValidGlobalContext();
1935 if (context)
1936 {
1937 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1938 bool isCallValid =
1939 (context->skipValidation() || ValidateViewportArrayv(context, first, count, v));
1940 if (isCallValid)
1941 {
1942 context->viewportArrayv(first, count, v);
1943 }
1944 ANGLE_CAPTURE(ViewportArrayv, isCallValid, context, first, count, v);
1945 }
1946 }
1947
ViewportIndexedf(GLuint index,GLfloat x,GLfloat y,GLfloat w,GLfloat h)1948 void GL_APIENTRY ViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
1949 {
1950 EVENT("(GLuint index = %u, GLfloat x = %f, GLfloat y = %f, GLfloat w = %f, GLfloat h = %f)",
1951 index, x, y, w, h);
1952
1953 Context *context = GetValidGlobalContext();
1954 if (context)
1955 {
1956 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1957 bool isCallValid =
1958 (context->skipValidation() || ValidateViewportIndexedf(context, index, x, y, w, h));
1959 if (isCallValid)
1960 {
1961 context->viewportIndexedf(index, x, y, w, h);
1962 }
1963 ANGLE_CAPTURE(ViewportIndexedf, isCallValid, context, index, x, y, w, h);
1964 }
1965 }
1966
ViewportIndexedfv(GLuint index,const GLfloat * v)1967 void GL_APIENTRY ViewportIndexedfv(GLuint index, const GLfloat *v)
1968 {
1969 EVENT("(GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
1970
1971 Context *context = GetValidGlobalContext();
1972 if (context)
1973 {
1974 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
1975 bool isCallValid =
1976 (context->skipValidation() || ValidateViewportIndexedfv(context, index, v));
1977 if (isCallValid)
1978 {
1979 context->viewportIndexedfv(index, v);
1980 }
1981 ANGLE_CAPTURE(ViewportIndexedfv, isCallValid, context, index, v);
1982 }
1983 }
1984 } // namespace gl
1985