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