1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml.
3 //
4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // entry_points_gles_3_1_autogen.cpp:
9 // Defines the GLES 3.1 entry points.
10
11 #include "libGLESv2/entry_points_gles_3_1_autogen.h"
12
13 #include "libANGLE/Context.h"
14 #include "libANGLE/Context.inl.h"
15 #include "libANGLE/capture_gles_3_1_autogen.h"
16 #include "libANGLE/entry_points_utils.h"
17 #include "libANGLE/gl_enum_utils.h"
18 #include "libANGLE/validationES31.h"
19 #include "libGLESv2/global_state.h"
20
21 namespace gl
22 {
ActiveShaderProgram(GLuint pipeline,GLuint program)23 void GL_APIENTRY ActiveShaderProgram(GLuint pipeline, GLuint program)
24 {
25 Context *context = GetValidGlobalContext();
26 EVENT("glActiveShaderProgram", "context = %d, GLuint pipeline = %u, GLuint program = %u",
27 CID(context), pipeline, program);
28
29 if (context)
30 {
31 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
32 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
33 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
34 bool isCallValid = (context->skipValidation() ||
35 ValidateActiveShaderProgram(context, pipelinePacked, programPacked));
36 if (isCallValid)
37 {
38 context->activeShaderProgram(pipelinePacked, programPacked);
39 }
40 ANGLE_CAPTURE(ActiveShaderProgram, isCallValid, context, pipelinePacked, programPacked);
41 }
42 }
43
BindImageTexture(GLuint unit,GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum access,GLenum format)44 void GL_APIENTRY BindImageTexture(GLuint unit,
45 GLuint texture,
46 GLint level,
47 GLboolean layered,
48 GLint layer,
49 GLenum access,
50 GLenum format)
51 {
52 Context *context = GetValidGlobalContext();
53 EVENT("glBindImageTexture",
54 "context = %d, GLuint unit = %u, GLuint texture = %u, GLint level = %d, GLboolean "
55 "layered = %s, GLint layer = %d, GLenum access = %s, GLenum format = %s",
56 CID(context), unit, texture, level, GLbooleanToString(layered), layer,
57 GLenumToString(GLenumGroup::BufferAccessARB, access),
58 GLenumToString(GLenumGroup::InternalFormat, format));
59
60 if (context)
61 {
62 TextureID texturePacked = FromGL<TextureID>(texture);
63 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
64 bool isCallValid = (context->skipValidation() ||
65 ValidateBindImageTexture(context, unit, texturePacked, level, layered,
66 layer, access, format));
67 if (isCallValid)
68 {
69 context->bindImageTexture(unit, texturePacked, level, layered, layer, access, format);
70 }
71 ANGLE_CAPTURE(BindImageTexture, isCallValid, context, unit, texturePacked, level, layered,
72 layer, access, format);
73 }
74 }
75
BindProgramPipeline(GLuint pipeline)76 void GL_APIENTRY BindProgramPipeline(GLuint pipeline)
77 {
78 Context *context = GetValidGlobalContext();
79 EVENT("glBindProgramPipeline", "context = %d, GLuint pipeline = %u", CID(context), pipeline);
80
81 if (context)
82 {
83 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
84 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
85 bool isCallValid =
86 (context->skipValidation() || ValidateBindProgramPipeline(context, pipelinePacked));
87 if (isCallValid)
88 {
89 context->bindProgramPipeline(pipelinePacked);
90 }
91 ANGLE_CAPTURE(BindProgramPipeline, isCallValid, context, pipelinePacked);
92 }
93 }
94
BindVertexBuffer(GLuint bindingindex,GLuint buffer,GLintptr offset,GLsizei stride)95 void GL_APIENTRY BindVertexBuffer(GLuint bindingindex,
96 GLuint buffer,
97 GLintptr offset,
98 GLsizei stride)
99 {
100 Context *context = GetValidGlobalContext();
101 EVENT("glBindVertexBuffer",
102 "context = %d, GLuint bindingindex = %u, GLuint buffer = %u, GLintptr offset = %llu, "
103 "GLsizei stride = %d",
104 CID(context), bindingindex, buffer, static_cast<unsigned long long>(offset), stride);
105
106 if (context)
107 {
108 BufferID bufferPacked = FromGL<BufferID>(buffer);
109 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
110 bool isCallValid =
111 (context->skipValidation() ||
112 ValidateBindVertexBuffer(context, bindingindex, bufferPacked, offset, stride));
113 if (isCallValid)
114 {
115 context->bindVertexBuffer(bindingindex, bufferPacked, offset, stride);
116 }
117 ANGLE_CAPTURE(BindVertexBuffer, isCallValid, context, bindingindex, bufferPacked, offset,
118 stride);
119 }
120 }
121
CreateShaderProgramv(GLenum type,GLsizei count,const GLchar * const * strings)122 GLuint GL_APIENTRY CreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
123 {
124 Context *context = GetValidGlobalContext();
125 EVENT("glCreateShaderProgramv",
126 "context = %d, GLenum type = %s, GLsizei count = %d, const GLchar *const*strings = "
127 "0x%016" PRIxPTR "",
128 CID(context), GLenumToString(GLenumGroup::ShaderType, type), count, (uintptr_t)strings);
129
130 GLuint returnValue;
131 if (context)
132 {
133 ShaderType typePacked = FromGL<ShaderType>(type);
134 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
135 bool isCallValid = (context->skipValidation() ||
136 ValidateCreateShaderProgramv(context, typePacked, count, strings));
137 if (isCallValid)
138 {
139 returnValue = context->createShaderProgramv(typePacked, count, strings);
140 }
141 else
142 {
143 returnValue = GetDefaultReturnValue<EntryPoint::CreateShaderProgramv, GLuint>();
144 }
145 ANGLE_CAPTURE(CreateShaderProgramv, isCallValid, context, typePacked, count, strings,
146 returnValue);
147 }
148 else
149 {
150 returnValue = GetDefaultReturnValue<EntryPoint::CreateShaderProgramv, GLuint>();
151 }
152 return returnValue;
153 }
154
DeleteProgramPipelines(GLsizei n,const GLuint * pipelines)155 void GL_APIENTRY DeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
156 {
157 Context *context = GetValidGlobalContext();
158 EVENT("glDeleteProgramPipelines",
159 "context = %d, GLsizei n = %d, const GLuint *pipelines = 0x%016" PRIxPTR "", CID(context),
160 n, (uintptr_t)pipelines);
161
162 if (context)
163 {
164 const ProgramPipelineID *pipelinesPacked = FromGL<const ProgramPipelineID *>(pipelines);
165 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
166 bool isCallValid = (context->skipValidation() ||
167 ValidateDeleteProgramPipelines(context, n, pipelinesPacked));
168 if (isCallValid)
169 {
170 context->deleteProgramPipelines(n, pipelinesPacked);
171 }
172 ANGLE_CAPTURE(DeleteProgramPipelines, isCallValid, context, n, pipelinesPacked);
173 }
174 }
175
DispatchCompute(GLuint num_groups_x,GLuint num_groups_y,GLuint num_groups_z)176 void GL_APIENTRY DispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
177 {
178 Context *context = GetValidGlobalContext();
179 EVENT("glDispatchCompute",
180 "context = %d, GLuint num_groups_x = %u, GLuint num_groups_y = %u, GLuint num_groups_z = "
181 "%u",
182 CID(context), num_groups_x, num_groups_y, num_groups_z);
183
184 if (context)
185 {
186 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
187 bool isCallValid =
188 (context->skipValidation() ||
189 ValidateDispatchCompute(context, num_groups_x, num_groups_y, num_groups_z));
190 if (isCallValid)
191 {
192 context->dispatchCompute(num_groups_x, num_groups_y, num_groups_z);
193 }
194 ANGLE_CAPTURE(DispatchCompute, isCallValid, context, num_groups_x, num_groups_y,
195 num_groups_z);
196 }
197 }
198
DispatchComputeIndirect(GLintptr indirect)199 void GL_APIENTRY DispatchComputeIndirect(GLintptr indirect)
200 {
201 Context *context = GetValidGlobalContext();
202 EVENT("glDispatchComputeIndirect", "context = %d, GLintptr indirect = %llu", CID(context),
203 static_cast<unsigned long long>(indirect));
204
205 if (context)
206 {
207 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
208 bool isCallValid =
209 (context->skipValidation() || ValidateDispatchComputeIndirect(context, indirect));
210 if (isCallValid)
211 {
212 context->dispatchComputeIndirect(indirect);
213 }
214 ANGLE_CAPTURE(DispatchComputeIndirect, isCallValid, context, indirect);
215 }
216 }
217
DrawArraysIndirect(GLenum mode,const void * indirect)218 void GL_APIENTRY DrawArraysIndirect(GLenum mode, const void *indirect)
219 {
220 Context *context = GetValidGlobalContext();
221 EVENT("glDrawArraysIndirect",
222 "context = %d, GLenum mode = %s, const void *indirect = 0x%016" PRIxPTR "", CID(context),
223 GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)indirect);
224
225 if (context)
226 {
227 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
228 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
229 bool isCallValid = (context->skipValidation() ||
230 ValidateDrawArraysIndirect(context, modePacked, indirect));
231 if (isCallValid)
232 {
233 context->drawArraysIndirect(modePacked, indirect);
234 }
235 ANGLE_CAPTURE(DrawArraysIndirect, isCallValid, context, modePacked, indirect);
236 }
237 }
238
DrawElementsIndirect(GLenum mode,GLenum type,const void * indirect)239 void GL_APIENTRY DrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
240 {
241 Context *context = GetValidGlobalContext();
242 EVENT("glDrawElementsIndirect",
243 "context = %d, GLenum mode = %s, GLenum type = %s, const void *indirect = 0x%016" PRIxPTR
244 "",
245 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode),
246 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indirect);
247
248 if (context)
249 {
250 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
251 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
252 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
253 bool isCallValid =
254 (context->skipValidation() ||
255 ValidateDrawElementsIndirect(context, modePacked, typePacked, indirect));
256 if (isCallValid)
257 {
258 context->drawElementsIndirect(modePacked, typePacked, indirect);
259 }
260 ANGLE_CAPTURE(DrawElementsIndirect, isCallValid, context, modePacked, typePacked, indirect);
261 }
262 }
263
FramebufferParameteri(GLenum target,GLenum pname,GLint param)264 void GL_APIENTRY FramebufferParameteri(GLenum target, GLenum pname, GLint param)
265 {
266 Context *context = GetValidGlobalContext();
267 EVENT("glFramebufferParameteri",
268 "context = %d, GLenum target = %s, GLenum pname = %s, GLint param = %d", CID(context),
269 GLenumToString(GLenumGroup::FramebufferTarget, target),
270 GLenumToString(GLenumGroup::FramebufferParameterName, pname), param);
271
272 if (context)
273 {
274 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
275 bool isCallValid = (context->skipValidation() ||
276 ValidateFramebufferParameteri(context, target, pname, param));
277 if (isCallValid)
278 {
279 context->framebufferParameteri(target, pname, param);
280 }
281 ANGLE_CAPTURE(FramebufferParameteri, isCallValid, context, target, pname, param);
282 }
283 }
284
GenProgramPipelines(GLsizei n,GLuint * pipelines)285 void GL_APIENTRY GenProgramPipelines(GLsizei n, GLuint *pipelines)
286 {
287 Context *context = GetValidGlobalContext();
288 EVENT("glGenProgramPipelines",
289 "context = %d, GLsizei n = %d, GLuint *pipelines = 0x%016" PRIxPTR "", CID(context), n,
290 (uintptr_t)pipelines);
291
292 if (context)
293 {
294 ProgramPipelineID *pipelinesPacked = FromGL<ProgramPipelineID *>(pipelines);
295 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
296 bool isCallValid =
297 (context->skipValidation() || ValidateGenProgramPipelines(context, n, pipelinesPacked));
298 if (isCallValid)
299 {
300 context->genProgramPipelines(n, pipelinesPacked);
301 }
302 ANGLE_CAPTURE(GenProgramPipelines, isCallValid, context, n, pipelinesPacked);
303 }
304 }
305
GetBooleani_v(GLenum target,GLuint index,GLboolean * data)306 void GL_APIENTRY GetBooleani_v(GLenum target, GLuint index, GLboolean *data)
307 {
308 Context *context = GetValidGlobalContext();
309 EVENT(
310 "glGetBooleani_v",
311 "context = %d, GLenum target = %s, GLuint index = %u, GLboolean *data = 0x%016" PRIxPTR "",
312 CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), index, (uintptr_t)data);
313
314 if (context)
315 {
316 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
317 bool isCallValid =
318 (context->skipValidation() || ValidateGetBooleani_v(context, target, index, data));
319 if (isCallValid)
320 {
321 context->getBooleani_v(target, index, data);
322 }
323 ANGLE_CAPTURE(GetBooleani_v, isCallValid, context, target, index, data);
324 }
325 }
326
GetFramebufferParameteriv(GLenum target,GLenum pname,GLint * params)327 void GL_APIENTRY GetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
328 {
329 Context *context = GetValidGlobalContext();
330 EVENT("glGetFramebufferParameteriv",
331 "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
332 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
333 GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname),
334 (uintptr_t)params);
335
336 if (context)
337 {
338 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
339 bool isCallValid = (context->skipValidation() ||
340 ValidateGetFramebufferParameteriv(context, target, pname, params));
341 if (isCallValid)
342 {
343 context->getFramebufferParameteriv(target, pname, params);
344 }
345 ANGLE_CAPTURE(GetFramebufferParameteriv, isCallValid, context, target, pname, params);
346 }
347 }
348
GetMultisamplefv(GLenum pname,GLuint index,GLfloat * val)349 void GL_APIENTRY GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
350 {
351 Context *context = GetValidGlobalContext();
352 EVENT("glGetMultisamplefv",
353 "context = %d, GLenum pname = %s, GLuint index = %u, GLfloat *val = 0x%016" PRIxPTR "",
354 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), index, (uintptr_t)val);
355
356 if (context)
357 {
358 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
359 bool isCallValid =
360 (context->skipValidation() || ValidateGetMultisamplefv(context, pname, index, val));
361 if (isCallValid)
362 {
363 context->getMultisamplefv(pname, index, val);
364 }
365 ANGLE_CAPTURE(GetMultisamplefv, isCallValid, context, pname, index, val);
366 }
367 }
368
GetProgramInterfaceiv(GLuint program,GLenum programInterface,GLenum pname,GLint * params)369 void GL_APIENTRY GetProgramInterfaceiv(GLuint program,
370 GLenum programInterface,
371 GLenum pname,
372 GLint *params)
373 {
374 Context *context = GetValidGlobalContext();
375 EVENT("glGetProgramInterfaceiv",
376 "context = %d, GLuint program = %u, GLenum programInterface = %s, GLenum pname = %s, "
377 "GLint *params = 0x%016" PRIxPTR "",
378 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
379 GLenumToString(GLenumGroup::ProgramInterfacePName, pname), (uintptr_t)params);
380
381 if (context)
382 {
383 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
384 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
385 bool isCallValid = (context->skipValidation() ||
386 ValidateGetProgramInterfaceiv(context, programPacked, programInterface,
387 pname, params));
388 if (isCallValid)
389 {
390 context->getProgramInterfaceiv(programPacked, programInterface, pname, params);
391 }
392 ANGLE_CAPTURE(GetProgramInterfaceiv, isCallValid, context, programPacked, programInterface,
393 pname, params);
394 }
395 }
396
GetProgramPipelineInfoLog(GLuint pipeline,GLsizei bufSize,GLsizei * length,GLchar * infoLog)397 void GL_APIENTRY GetProgramPipelineInfoLog(GLuint pipeline,
398 GLsizei bufSize,
399 GLsizei *length,
400 GLchar *infoLog)
401 {
402 Context *context = GetValidGlobalContext();
403 EVENT(
404 "glGetProgramPipelineInfoLog",
405 "context = %d, GLuint pipeline = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
406 ", GLchar *infoLog = 0x%016" PRIxPTR "",
407 CID(context), pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
408
409 if (context)
410 {
411 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
412 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
413 bool isCallValid =
414 (context->skipValidation() ||
415 ValidateGetProgramPipelineInfoLog(context, pipelinePacked, bufSize, length, infoLog));
416 if (isCallValid)
417 {
418 context->getProgramPipelineInfoLog(pipelinePacked, bufSize, length, infoLog);
419 }
420 ANGLE_CAPTURE(GetProgramPipelineInfoLog, isCallValid, context, pipelinePacked, bufSize,
421 length, infoLog);
422 }
423 }
424
GetProgramPipelineiv(GLuint pipeline,GLenum pname,GLint * params)425 void GL_APIENTRY GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
426 {
427 Context *context = GetValidGlobalContext();
428 EVENT("glGetProgramPipelineiv",
429 "context = %d, GLuint pipeline = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR
430 "",
431 CID(context), pipeline, GLenumToString(GLenumGroup::PipelineParameterName, pname),
432 (uintptr_t)params);
433
434 if (context)
435 {
436 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
437 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
438 bool isCallValid = (context->skipValidation() ||
439 ValidateGetProgramPipelineiv(context, pipelinePacked, pname, params));
440 if (isCallValid)
441 {
442 context->getProgramPipelineiv(pipelinePacked, pname, params);
443 }
444 ANGLE_CAPTURE(GetProgramPipelineiv, isCallValid, context, pipelinePacked, pname, params);
445 }
446 }
447
GetProgramResourceIndex(GLuint program,GLenum programInterface,const GLchar * name)448 GLuint GL_APIENTRY GetProgramResourceIndex(GLuint program,
449 GLenum programInterface,
450 const GLchar *name)
451 {
452 Context *context = GetValidGlobalContext();
453 EVENT("glGetProgramResourceIndex",
454 "context = %d, GLuint program = %u, GLenum programInterface = %s, const GLchar *name = "
455 "0x%016" PRIxPTR "",
456 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
457 (uintptr_t)name);
458
459 GLuint returnValue;
460 if (context)
461 {
462 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
463 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
464 bool isCallValid =
465 (context->skipValidation() ||
466 ValidateGetProgramResourceIndex(context, programPacked, programInterface, name));
467 if (isCallValid)
468 {
469 returnValue = context->getProgramResourceIndex(programPacked, programInterface, name);
470 }
471 else
472 {
473 returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceIndex, GLuint>();
474 }
475 ANGLE_CAPTURE(GetProgramResourceIndex, isCallValid, context, programPacked,
476 programInterface, name, returnValue);
477 }
478 else
479 {
480 returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceIndex, GLuint>();
481 }
482 return returnValue;
483 }
484
GetProgramResourceLocation(GLuint program,GLenum programInterface,const GLchar * name)485 GLint GL_APIENTRY GetProgramResourceLocation(GLuint program,
486 GLenum programInterface,
487 const GLchar *name)
488 {
489 Context *context = GetValidGlobalContext();
490 EVENT("glGetProgramResourceLocation",
491 "context = %d, GLuint program = %u, GLenum programInterface = %s, const GLchar *name = "
492 "0x%016" PRIxPTR "",
493 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
494 (uintptr_t)name);
495
496 GLint returnValue;
497 if (context)
498 {
499 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
500 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
501 bool isCallValid =
502 (context->skipValidation() ||
503 ValidateGetProgramResourceLocation(context, programPacked, programInterface, name));
504 if (isCallValid)
505 {
506 returnValue =
507 context->getProgramResourceLocation(programPacked, programInterface, name);
508 }
509 else
510 {
511 returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceLocation, GLint>();
512 }
513 ANGLE_CAPTURE(GetProgramResourceLocation, isCallValid, context, programPacked,
514 programInterface, name, returnValue);
515 }
516 else
517 {
518 returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceLocation, GLint>();
519 }
520 return returnValue;
521 }
522
GetProgramResourceName(GLuint program,GLenum programInterface,GLuint index,GLsizei bufSize,GLsizei * length,GLchar * name)523 void GL_APIENTRY GetProgramResourceName(GLuint program,
524 GLenum programInterface,
525 GLuint index,
526 GLsizei bufSize,
527 GLsizei *length,
528 GLchar *name)
529 {
530 Context *context = GetValidGlobalContext();
531 EVENT("glGetProgramResourceName",
532 "context = %d, GLuint program = %u, GLenum programInterface = %s, GLuint index = %u, "
533 "GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR
534 "",
535 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
536 index, bufSize, (uintptr_t)length, (uintptr_t)name);
537
538 if (context)
539 {
540 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
541 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
542 bool isCallValid = (context->skipValidation() ||
543 ValidateGetProgramResourceName(context, programPacked, programInterface,
544 index, bufSize, length, name));
545 if (isCallValid)
546 {
547 context->getProgramResourceName(programPacked, programInterface, index, bufSize, length,
548 name);
549 }
550 ANGLE_CAPTURE(GetProgramResourceName, isCallValid, context, programPacked, programInterface,
551 index, bufSize, length, name);
552 }
553 }
554
GetProgramResourceiv(GLuint program,GLenum programInterface,GLuint index,GLsizei propCount,const GLenum * props,GLsizei bufSize,GLsizei * length,GLint * params)555 void GL_APIENTRY GetProgramResourceiv(GLuint program,
556 GLenum programInterface,
557 GLuint index,
558 GLsizei propCount,
559 const GLenum *props,
560 GLsizei bufSize,
561 GLsizei *length,
562 GLint *params)
563 {
564 Context *context = GetValidGlobalContext();
565 EVENT("glGetProgramResourceiv",
566 "context = %d, GLuint program = %u, GLenum programInterface = %s, GLuint index = %u, "
567 "GLsizei propCount = %d, const GLenum *props = 0x%016" PRIxPTR
568 ", GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
569 ", GLint *params = 0x%016" PRIxPTR "",
570 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
571 index, propCount, (uintptr_t)props, bufSize, (uintptr_t)length, (uintptr_t)params);
572
573 if (context)
574 {
575 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
576 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
577 bool isCallValid =
578 (context->skipValidation() ||
579 ValidateGetProgramResourceiv(context, programPacked, programInterface, index,
580 propCount, props, bufSize, length, params));
581 if (isCallValid)
582 {
583 context->getProgramResourceiv(programPacked, programInterface, index, propCount, props,
584 bufSize, length, params);
585 }
586 ANGLE_CAPTURE(GetProgramResourceiv, isCallValid, context, programPacked, programInterface,
587 index, propCount, props, bufSize, length, params);
588 }
589 }
590
GetTexLevelParameterfv(GLenum target,GLint level,GLenum pname,GLfloat * params)591 void GL_APIENTRY GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
592 {
593 Context *context = GetValidGlobalContext();
594 EVENT("glGetTexLevelParameterfv",
595 "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLfloat *params "
596 "= 0x%016" PRIxPTR "",
597 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
598 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
599
600 if (context)
601 {
602 TextureTarget targetPacked = FromGL<TextureTarget>(target);
603 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
604 bool isCallValid =
605 (context->skipValidation() ||
606 ValidateGetTexLevelParameterfv(context, targetPacked, level, pname, params));
607 if (isCallValid)
608 {
609 context->getTexLevelParameterfv(targetPacked, level, pname, params);
610 }
611 ANGLE_CAPTURE(GetTexLevelParameterfv, isCallValid, context, targetPacked, level, pname,
612 params);
613 }
614 }
615
GetTexLevelParameteriv(GLenum target,GLint level,GLenum pname,GLint * params)616 void GL_APIENTRY GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
617 {
618 Context *context = GetValidGlobalContext();
619 EVENT("glGetTexLevelParameteriv",
620 "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLint *params = "
621 "0x%016" PRIxPTR "",
622 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
623 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
624
625 if (context)
626 {
627 TextureTarget targetPacked = FromGL<TextureTarget>(target);
628 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
629 bool isCallValid =
630 (context->skipValidation() ||
631 ValidateGetTexLevelParameteriv(context, targetPacked, level, pname, params));
632 if (isCallValid)
633 {
634 context->getTexLevelParameteriv(targetPacked, level, pname, params);
635 }
636 ANGLE_CAPTURE(GetTexLevelParameteriv, isCallValid, context, targetPacked, level, pname,
637 params);
638 }
639 }
640
IsProgramPipeline(GLuint pipeline)641 GLboolean GL_APIENTRY IsProgramPipeline(GLuint pipeline)
642 {
643 Context *context = GetValidGlobalContext();
644 EVENT("glIsProgramPipeline", "context = %d, GLuint pipeline = %u", CID(context), pipeline);
645
646 GLboolean returnValue;
647 if (context)
648 {
649 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
650 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
651 bool isCallValid =
652 (context->skipValidation() || ValidateIsProgramPipeline(context, pipelinePacked));
653 if (isCallValid)
654 {
655 returnValue = context->isProgramPipeline(pipelinePacked);
656 }
657 else
658 {
659 returnValue = GetDefaultReturnValue<EntryPoint::IsProgramPipeline, GLboolean>();
660 }
661 ANGLE_CAPTURE(IsProgramPipeline, isCallValid, context, pipelinePacked, returnValue);
662 }
663 else
664 {
665 returnValue = GetDefaultReturnValue<EntryPoint::IsProgramPipeline, GLboolean>();
666 }
667 return returnValue;
668 }
669
MemoryBarrier(GLbitfield barriers)670 void GL_APIENTRY MemoryBarrier(GLbitfield barriers)
671 {
672 Context *context = GetValidGlobalContext();
673 EVENT("glMemoryBarrier", "context = %d, GLbitfield barriers = %s", CID(context),
674 GLbitfieldToString(GLenumGroup::MemoryBarrierMask, barriers).c_str());
675
676 if (context)
677 {
678 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
679 bool isCallValid = (context->skipValidation() || ValidateMemoryBarrier(context, barriers));
680 if (isCallValid)
681 {
682 context->memoryBarrier(barriers);
683 }
684 ANGLE_CAPTURE(MemoryBarrier, isCallValid, context, barriers);
685 }
686 }
687
MemoryBarrierByRegion(GLbitfield barriers)688 void GL_APIENTRY MemoryBarrierByRegion(GLbitfield barriers)
689 {
690 Context *context = GetValidGlobalContext();
691 EVENT("glMemoryBarrierByRegion", "context = %d, GLbitfield barriers = %s", CID(context),
692 GLbitfieldToString(GLenumGroup::MemoryBarrierMask, barriers).c_str());
693
694 if (context)
695 {
696 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
697 bool isCallValid =
698 (context->skipValidation() || ValidateMemoryBarrierByRegion(context, barriers));
699 if (isCallValid)
700 {
701 context->memoryBarrierByRegion(barriers);
702 }
703 ANGLE_CAPTURE(MemoryBarrierByRegion, isCallValid, context, barriers);
704 }
705 }
706
ProgramUniform1f(GLuint program,GLint location,GLfloat v0)707 void GL_APIENTRY ProgramUniform1f(GLuint program, GLint location, GLfloat v0)
708 {
709 Context *context = GetValidGlobalContext();
710 EVENT("glProgramUniform1f",
711 "context = %d, GLuint program = %u, GLint location = %d, GLfloat v0 = %f", CID(context),
712 program, location, v0);
713
714 if (context)
715 {
716 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
717 UniformLocation locationPacked = FromGL<UniformLocation>(location);
718 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
719 bool isCallValid = (context->skipValidation() ||
720 ValidateProgramUniform1f(context, programPacked, locationPacked, v0));
721 if (isCallValid)
722 {
723 context->programUniform1f(programPacked, locationPacked, v0);
724 }
725 ANGLE_CAPTURE(ProgramUniform1f, isCallValid, context, programPacked, locationPacked, v0);
726 }
727 }
728
ProgramUniform1fv(GLuint program,GLint location,GLsizei count,const GLfloat * value)729 void GL_APIENTRY ProgramUniform1fv(GLuint program,
730 GLint location,
731 GLsizei count,
732 const GLfloat *value)
733 {
734 Context *context = GetValidGlobalContext();
735 EVENT("glProgramUniform1fv",
736 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
737 "GLfloat *value = 0x%016" PRIxPTR "",
738 CID(context), program, location, count, (uintptr_t)value);
739
740 if (context)
741 {
742 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
743 UniformLocation locationPacked = FromGL<UniformLocation>(location);
744 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
745 bool isCallValid =
746 (context->skipValidation() ||
747 ValidateProgramUniform1fv(context, programPacked, locationPacked, count, value));
748 if (isCallValid)
749 {
750 context->programUniform1fv(programPacked, locationPacked, count, value);
751 }
752 ANGLE_CAPTURE(ProgramUniform1fv, isCallValid, context, programPacked, locationPacked, count,
753 value);
754 }
755 }
756
ProgramUniform1i(GLuint program,GLint location,GLint v0)757 void GL_APIENTRY ProgramUniform1i(GLuint program, GLint location, GLint v0)
758 {
759 Context *context = GetValidGlobalContext();
760 EVENT("glProgramUniform1i",
761 "context = %d, GLuint program = %u, GLint location = %d, GLint v0 = %d", CID(context),
762 program, location, v0);
763
764 if (context)
765 {
766 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
767 UniformLocation locationPacked = FromGL<UniformLocation>(location);
768 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
769 bool isCallValid = (context->skipValidation() ||
770 ValidateProgramUniform1i(context, programPacked, locationPacked, v0));
771 if (isCallValid)
772 {
773 context->programUniform1i(programPacked, locationPacked, v0);
774 }
775 ANGLE_CAPTURE(ProgramUniform1i, isCallValid, context, programPacked, locationPacked, v0);
776 }
777 }
778
ProgramUniform1iv(GLuint program,GLint location,GLsizei count,const GLint * value)779 void GL_APIENTRY ProgramUniform1iv(GLuint program,
780 GLint location,
781 GLsizei count,
782 const GLint *value)
783 {
784 Context *context = GetValidGlobalContext();
785 EVENT("glProgramUniform1iv",
786 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint "
787 "*value = 0x%016" PRIxPTR "",
788 CID(context), program, location, count, (uintptr_t)value);
789
790 if (context)
791 {
792 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
793 UniformLocation locationPacked = FromGL<UniformLocation>(location);
794 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
795 bool isCallValid =
796 (context->skipValidation() ||
797 ValidateProgramUniform1iv(context, programPacked, locationPacked, count, value));
798 if (isCallValid)
799 {
800 context->programUniform1iv(programPacked, locationPacked, count, value);
801 }
802 ANGLE_CAPTURE(ProgramUniform1iv, isCallValid, context, programPacked, locationPacked, count,
803 value);
804 }
805 }
806
ProgramUniform1ui(GLuint program,GLint location,GLuint v0)807 void GL_APIENTRY ProgramUniform1ui(GLuint program, GLint location, GLuint v0)
808 {
809 Context *context = GetValidGlobalContext();
810 EVENT("glProgramUniform1ui",
811 "context = %d, GLuint program = %u, GLint location = %d, GLuint v0 = %u", CID(context),
812 program, location, v0);
813
814 if (context)
815 {
816 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
817 UniformLocation locationPacked = FromGL<UniformLocation>(location);
818 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
819 bool isCallValid = (context->skipValidation() ||
820 ValidateProgramUniform1ui(context, programPacked, locationPacked, v0));
821 if (isCallValid)
822 {
823 context->programUniform1ui(programPacked, locationPacked, v0);
824 }
825 ANGLE_CAPTURE(ProgramUniform1ui, isCallValid, context, programPacked, locationPacked, v0);
826 }
827 }
828
ProgramUniform1uiv(GLuint program,GLint location,GLsizei count,const GLuint * value)829 void GL_APIENTRY ProgramUniform1uiv(GLuint program,
830 GLint location,
831 GLsizei count,
832 const GLuint *value)
833 {
834 Context *context = GetValidGlobalContext();
835 EVENT("glProgramUniform1uiv",
836 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
837 "GLuint *value = 0x%016" PRIxPTR "",
838 CID(context), program, location, count, (uintptr_t)value);
839
840 if (context)
841 {
842 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
843 UniformLocation locationPacked = FromGL<UniformLocation>(location);
844 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
845 bool isCallValid =
846 (context->skipValidation() ||
847 ValidateProgramUniform1uiv(context, programPacked, locationPacked, count, value));
848 if (isCallValid)
849 {
850 context->programUniform1uiv(programPacked, locationPacked, count, value);
851 }
852 ANGLE_CAPTURE(ProgramUniform1uiv, isCallValid, context, programPacked, locationPacked,
853 count, value);
854 }
855 }
856
ProgramUniform2f(GLuint program,GLint location,GLfloat v0,GLfloat v1)857 void GL_APIENTRY ProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
858 {
859 Context *context = GetValidGlobalContext();
860 EVENT(
861 "glProgramUniform2f",
862 "context = %d, GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f",
863 CID(context), program, location, v0, v1);
864
865 if (context)
866 {
867 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
868 UniformLocation locationPacked = FromGL<UniformLocation>(location);
869 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
870 bool isCallValid =
871 (context->skipValidation() ||
872 ValidateProgramUniform2f(context, programPacked, locationPacked, v0, v1));
873 if (isCallValid)
874 {
875 context->programUniform2f(programPacked, locationPacked, v0, v1);
876 }
877 ANGLE_CAPTURE(ProgramUniform2f, isCallValid, context, programPacked, locationPacked, v0,
878 v1);
879 }
880 }
881
ProgramUniform2fv(GLuint program,GLint location,GLsizei count,const GLfloat * value)882 void GL_APIENTRY ProgramUniform2fv(GLuint program,
883 GLint location,
884 GLsizei count,
885 const GLfloat *value)
886 {
887 Context *context = GetValidGlobalContext();
888 EVENT("glProgramUniform2fv",
889 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
890 "GLfloat *value = 0x%016" PRIxPTR "",
891 CID(context), program, location, count, (uintptr_t)value);
892
893 if (context)
894 {
895 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
896 UniformLocation locationPacked = FromGL<UniformLocation>(location);
897 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
898 bool isCallValid =
899 (context->skipValidation() ||
900 ValidateProgramUniform2fv(context, programPacked, locationPacked, count, value));
901 if (isCallValid)
902 {
903 context->programUniform2fv(programPacked, locationPacked, count, value);
904 }
905 ANGLE_CAPTURE(ProgramUniform2fv, isCallValid, context, programPacked, locationPacked, count,
906 value);
907 }
908 }
909
ProgramUniform2i(GLuint program,GLint location,GLint v0,GLint v1)910 void GL_APIENTRY ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
911 {
912 Context *context = GetValidGlobalContext();
913 EVENT("glProgramUniform2i",
914 "context = %d, GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d",
915 CID(context), program, location, v0, v1);
916
917 if (context)
918 {
919 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
920 UniformLocation locationPacked = FromGL<UniformLocation>(location);
921 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
922 bool isCallValid =
923 (context->skipValidation() ||
924 ValidateProgramUniform2i(context, programPacked, locationPacked, v0, v1));
925 if (isCallValid)
926 {
927 context->programUniform2i(programPacked, locationPacked, v0, v1);
928 }
929 ANGLE_CAPTURE(ProgramUniform2i, isCallValid, context, programPacked, locationPacked, v0,
930 v1);
931 }
932 }
933
ProgramUniform2iv(GLuint program,GLint location,GLsizei count,const GLint * value)934 void GL_APIENTRY ProgramUniform2iv(GLuint program,
935 GLint location,
936 GLsizei count,
937 const GLint *value)
938 {
939 Context *context = GetValidGlobalContext();
940 EVENT("glProgramUniform2iv",
941 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint "
942 "*value = 0x%016" PRIxPTR "",
943 CID(context), program, location, count, (uintptr_t)value);
944
945 if (context)
946 {
947 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
948 UniformLocation locationPacked = FromGL<UniformLocation>(location);
949 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
950 bool isCallValid =
951 (context->skipValidation() ||
952 ValidateProgramUniform2iv(context, programPacked, locationPacked, count, value));
953 if (isCallValid)
954 {
955 context->programUniform2iv(programPacked, locationPacked, count, value);
956 }
957 ANGLE_CAPTURE(ProgramUniform2iv, isCallValid, context, programPacked, locationPacked, count,
958 value);
959 }
960 }
961
ProgramUniform2ui(GLuint program,GLint location,GLuint v0,GLuint v1)962 void GL_APIENTRY ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
963 {
964 Context *context = GetValidGlobalContext();
965 EVENT("glProgramUniform2ui",
966 "context = %d, GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u",
967 CID(context), program, location, v0, v1);
968
969 if (context)
970 {
971 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
972 UniformLocation locationPacked = FromGL<UniformLocation>(location);
973 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
974 bool isCallValid =
975 (context->skipValidation() ||
976 ValidateProgramUniform2ui(context, programPacked, locationPacked, v0, v1));
977 if (isCallValid)
978 {
979 context->programUniform2ui(programPacked, locationPacked, v0, v1);
980 }
981 ANGLE_CAPTURE(ProgramUniform2ui, isCallValid, context, programPacked, locationPacked, v0,
982 v1);
983 }
984 }
985
ProgramUniform2uiv(GLuint program,GLint location,GLsizei count,const GLuint * value)986 void GL_APIENTRY ProgramUniform2uiv(GLuint program,
987 GLint location,
988 GLsizei count,
989 const GLuint *value)
990 {
991 Context *context = GetValidGlobalContext();
992 EVENT("glProgramUniform2uiv",
993 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
994 "GLuint *value = 0x%016" PRIxPTR "",
995 CID(context), program, location, count, (uintptr_t)value);
996
997 if (context)
998 {
999 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1000 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1001 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1002 bool isCallValid =
1003 (context->skipValidation() ||
1004 ValidateProgramUniform2uiv(context, programPacked, locationPacked, count, value));
1005 if (isCallValid)
1006 {
1007 context->programUniform2uiv(programPacked, locationPacked, count, value);
1008 }
1009 ANGLE_CAPTURE(ProgramUniform2uiv, isCallValid, context, programPacked, locationPacked,
1010 count, value);
1011 }
1012 }
1013
1014 void GL_APIENTRY
ProgramUniform3f(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2)1015 ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
1016 {
1017 Context *context = GetValidGlobalContext();
1018 EVENT("glProgramUniform3f",
1019 "context = %d, GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = "
1020 "%f, GLfloat v2 = %f",
1021 CID(context), program, location, v0, v1, v2);
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 ValidateProgramUniform3f(context, programPacked, locationPacked, v0, v1, v2));
1031 if (isCallValid)
1032 {
1033 context->programUniform3f(programPacked, locationPacked, v0, v1, v2);
1034 }
1035 ANGLE_CAPTURE(ProgramUniform3f, isCallValid, context, programPacked, locationPacked, v0, v1,
1036 v2);
1037 }
1038 }
1039
ProgramUniform3fv(GLuint program,GLint location,GLsizei count,const GLfloat * value)1040 void GL_APIENTRY ProgramUniform3fv(GLuint program,
1041 GLint location,
1042 GLsizei count,
1043 const GLfloat *value)
1044 {
1045 Context *context = GetValidGlobalContext();
1046 EVENT("glProgramUniform3fv",
1047 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
1048 "GLfloat *value = 0x%016" PRIxPTR "",
1049 CID(context), program, location, count, (uintptr_t)value);
1050
1051 if (context)
1052 {
1053 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1054 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1055 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1056 bool isCallValid =
1057 (context->skipValidation() ||
1058 ValidateProgramUniform3fv(context, programPacked, locationPacked, count, value));
1059 if (isCallValid)
1060 {
1061 context->programUniform3fv(programPacked, locationPacked, count, value);
1062 }
1063 ANGLE_CAPTURE(ProgramUniform3fv, isCallValid, context, programPacked, locationPacked, count,
1064 value);
1065 }
1066 }
1067
ProgramUniform3i(GLuint program,GLint location,GLint v0,GLint v1,GLint v2)1068 void GL_APIENTRY ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
1069 {
1070 Context *context = GetValidGlobalContext();
1071 EVENT("glProgramUniform3i",
1072 "context = %d, GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, "
1073 "GLint v2 = %d",
1074 CID(context), program, location, v0, v1, v2);
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 ValidateProgramUniform3i(context, programPacked, locationPacked, v0, v1, v2));
1084 if (isCallValid)
1085 {
1086 context->programUniform3i(programPacked, locationPacked, v0, v1, v2);
1087 }
1088 ANGLE_CAPTURE(ProgramUniform3i, isCallValid, context, programPacked, locationPacked, v0, v1,
1089 v2);
1090 }
1091 }
1092
ProgramUniform3iv(GLuint program,GLint location,GLsizei count,const GLint * value)1093 void GL_APIENTRY ProgramUniform3iv(GLuint program,
1094 GLint location,
1095 GLsizei count,
1096 const GLint *value)
1097 {
1098 Context *context = GetValidGlobalContext();
1099 EVENT("glProgramUniform3iv",
1100 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint "
1101 "*value = 0x%016" PRIxPTR "",
1102 CID(context), program, location, count, (uintptr_t)value);
1103
1104 if (context)
1105 {
1106 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1107 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1108 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1109 bool isCallValid =
1110 (context->skipValidation() ||
1111 ValidateProgramUniform3iv(context, programPacked, locationPacked, count, value));
1112 if (isCallValid)
1113 {
1114 context->programUniform3iv(programPacked, locationPacked, count, value);
1115 }
1116 ANGLE_CAPTURE(ProgramUniform3iv, isCallValid, context, programPacked, locationPacked, count,
1117 value);
1118 }
1119 }
1120
ProgramUniform3ui(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2)1121 void GL_APIENTRY ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
1122 {
1123 Context *context = GetValidGlobalContext();
1124 EVENT("glProgramUniform3ui",
1125 "context = %d, GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, "
1126 "GLuint v2 = %u",
1127 CID(context), program, location, v0, v1, v2);
1128
1129 if (context)
1130 {
1131 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1132 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1133 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1134 bool isCallValid =
1135 (context->skipValidation() ||
1136 ValidateProgramUniform3ui(context, programPacked, locationPacked, v0, v1, v2));
1137 if (isCallValid)
1138 {
1139 context->programUniform3ui(programPacked, locationPacked, v0, v1, v2);
1140 }
1141 ANGLE_CAPTURE(ProgramUniform3ui, isCallValid, context, programPacked, locationPacked, v0,
1142 v1, v2);
1143 }
1144 }
1145
ProgramUniform3uiv(GLuint program,GLint location,GLsizei count,const GLuint * value)1146 void GL_APIENTRY ProgramUniform3uiv(GLuint program,
1147 GLint location,
1148 GLsizei count,
1149 const GLuint *value)
1150 {
1151 Context *context = GetValidGlobalContext();
1152 EVENT("glProgramUniform3uiv",
1153 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
1154 "GLuint *value = 0x%016" PRIxPTR "",
1155 CID(context), program, location, count, (uintptr_t)value);
1156
1157 if (context)
1158 {
1159 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1160 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1161 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1162 bool isCallValid =
1163 (context->skipValidation() ||
1164 ValidateProgramUniform3uiv(context, programPacked, locationPacked, count, value));
1165 if (isCallValid)
1166 {
1167 context->programUniform3uiv(programPacked, locationPacked, count, value);
1168 }
1169 ANGLE_CAPTURE(ProgramUniform3uiv, isCallValid, context, programPacked, locationPacked,
1170 count, value);
1171 }
1172 }
1173
1174 void GL_APIENTRY
ProgramUniform4f(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)1175 ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
1176 {
1177 Context *context = GetValidGlobalContext();
1178 EVENT("glProgramUniform4f",
1179 "context = %d, GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = "
1180 "%f, GLfloat v2 = %f, GLfloat v3 = %f",
1181 CID(context), program, location, v0, v1, v2, v3);
1182
1183 if (context)
1184 {
1185 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1186 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1187 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1188 bool isCallValid =
1189 (context->skipValidation() ||
1190 ValidateProgramUniform4f(context, programPacked, locationPacked, v0, v1, v2, v3));
1191 if (isCallValid)
1192 {
1193 context->programUniform4f(programPacked, locationPacked, v0, v1, v2, v3);
1194 }
1195 ANGLE_CAPTURE(ProgramUniform4f, isCallValid, context, programPacked, locationPacked, v0, v1,
1196 v2, v3);
1197 }
1198 }
1199
ProgramUniform4fv(GLuint program,GLint location,GLsizei count,const GLfloat * value)1200 void GL_APIENTRY ProgramUniform4fv(GLuint program,
1201 GLint location,
1202 GLsizei count,
1203 const GLfloat *value)
1204 {
1205 Context *context = GetValidGlobalContext();
1206 EVENT("glProgramUniform4fv",
1207 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
1208 "GLfloat *value = 0x%016" PRIxPTR "",
1209 CID(context), program, location, count, (uintptr_t)value);
1210
1211 if (context)
1212 {
1213 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1214 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1215 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1216 bool isCallValid =
1217 (context->skipValidation() ||
1218 ValidateProgramUniform4fv(context, programPacked, locationPacked, count, value));
1219 if (isCallValid)
1220 {
1221 context->programUniform4fv(programPacked, locationPacked, count, value);
1222 }
1223 ANGLE_CAPTURE(ProgramUniform4fv, isCallValid, context, programPacked, locationPacked, count,
1224 value);
1225 }
1226 }
1227
1228 void GL_APIENTRY
ProgramUniform4i(GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3)1229 ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
1230 {
1231 Context *context = GetValidGlobalContext();
1232 EVENT("glProgramUniform4i",
1233 "context = %d, GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, "
1234 "GLint v2 = %d, GLint v3 = %d",
1235 CID(context), program, location, v0, v1, v2, v3);
1236
1237 if (context)
1238 {
1239 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1240 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1241 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1242 bool isCallValid =
1243 (context->skipValidation() ||
1244 ValidateProgramUniform4i(context, programPacked, locationPacked, v0, v1, v2, v3));
1245 if (isCallValid)
1246 {
1247 context->programUniform4i(programPacked, locationPacked, v0, v1, v2, v3);
1248 }
1249 ANGLE_CAPTURE(ProgramUniform4i, isCallValid, context, programPacked, locationPacked, v0, v1,
1250 v2, v3);
1251 }
1252 }
1253
ProgramUniform4iv(GLuint program,GLint location,GLsizei count,const GLint * value)1254 void GL_APIENTRY ProgramUniform4iv(GLuint program,
1255 GLint location,
1256 GLsizei count,
1257 const GLint *value)
1258 {
1259 Context *context = GetValidGlobalContext();
1260 EVENT("glProgramUniform4iv",
1261 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint "
1262 "*value = 0x%016" PRIxPTR "",
1263 CID(context), program, location, count, (uintptr_t)value);
1264
1265 if (context)
1266 {
1267 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1268 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1269 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1270 bool isCallValid =
1271 (context->skipValidation() ||
1272 ValidateProgramUniform4iv(context, programPacked, locationPacked, count, value));
1273 if (isCallValid)
1274 {
1275 context->programUniform4iv(programPacked, locationPacked, count, value);
1276 }
1277 ANGLE_CAPTURE(ProgramUniform4iv, isCallValid, context, programPacked, locationPacked, count,
1278 value);
1279 }
1280 }
1281
1282 void GL_APIENTRY
ProgramUniform4ui(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)1283 ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
1284 {
1285 Context *context = GetValidGlobalContext();
1286 EVENT("glProgramUniform4ui",
1287 "context = %d, GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, "
1288 "GLuint v2 = %u, GLuint v3 = %u",
1289 CID(context), program, location, v0, v1, v2, v3);
1290
1291 if (context)
1292 {
1293 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1294 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1295 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1296 bool isCallValid =
1297 (context->skipValidation() ||
1298 ValidateProgramUniform4ui(context, programPacked, locationPacked, v0, v1, v2, v3));
1299 if (isCallValid)
1300 {
1301 context->programUniform4ui(programPacked, locationPacked, v0, v1, v2, v3);
1302 }
1303 ANGLE_CAPTURE(ProgramUniform4ui, isCallValid, context, programPacked, locationPacked, v0,
1304 v1, v2, v3);
1305 }
1306 }
1307
ProgramUniform4uiv(GLuint program,GLint location,GLsizei count,const GLuint * value)1308 void GL_APIENTRY ProgramUniform4uiv(GLuint program,
1309 GLint location,
1310 GLsizei count,
1311 const GLuint *value)
1312 {
1313 Context *context = GetValidGlobalContext();
1314 EVENT("glProgramUniform4uiv",
1315 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const "
1316 "GLuint *value = 0x%016" PRIxPTR "",
1317 CID(context), program, location, count, (uintptr_t)value);
1318
1319 if (context)
1320 {
1321 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1322 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1323 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1324 bool isCallValid =
1325 (context->skipValidation() ||
1326 ValidateProgramUniform4uiv(context, programPacked, locationPacked, count, value));
1327 if (isCallValid)
1328 {
1329 context->programUniform4uiv(programPacked, locationPacked, count, value);
1330 }
1331 ANGLE_CAPTURE(ProgramUniform4uiv, isCallValid, context, programPacked, locationPacked,
1332 count, value);
1333 }
1334 }
1335
ProgramUniformMatrix2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1336 void GL_APIENTRY ProgramUniformMatrix2fv(GLuint program,
1337 GLint location,
1338 GLsizei count,
1339 GLboolean transpose,
1340 const GLfloat *value)
1341 {
1342 Context *context = GetValidGlobalContext();
1343 EVENT("glProgramUniformMatrix2fv",
1344 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
1345 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
1346 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1347
1348 if (context)
1349 {
1350 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1351 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1352 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1353 bool isCallValid = (context->skipValidation() ||
1354 ValidateProgramUniformMatrix2fv(context, programPacked, locationPacked,
1355 count, transpose, value));
1356 if (isCallValid)
1357 {
1358 context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose,
1359 value);
1360 }
1361 ANGLE_CAPTURE(ProgramUniformMatrix2fv, isCallValid, context, programPacked, locationPacked,
1362 count, transpose, value);
1363 }
1364 }
1365
ProgramUniformMatrix2x3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1366 void GL_APIENTRY ProgramUniformMatrix2x3fv(GLuint program,
1367 GLint location,
1368 GLsizei count,
1369 GLboolean transpose,
1370 const GLfloat *value)
1371 {
1372 Context *context = GetValidGlobalContext();
1373 EVENT("glProgramUniformMatrix2x3fv",
1374 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
1375 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
1376 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1377
1378 if (context)
1379 {
1380 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1381 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1382 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1383 bool isCallValid = (context->skipValidation() ||
1384 ValidateProgramUniformMatrix2x3fv(
1385 context, programPacked, locationPacked, count, transpose, value));
1386 if (isCallValid)
1387 {
1388 context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose,
1389 value);
1390 }
1391 ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, isCallValid, context, programPacked,
1392 locationPacked, count, transpose, value);
1393 }
1394 }
1395
ProgramUniformMatrix2x4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1396 void GL_APIENTRY ProgramUniformMatrix2x4fv(GLuint program,
1397 GLint location,
1398 GLsizei count,
1399 GLboolean transpose,
1400 const GLfloat *value)
1401 {
1402 Context *context = GetValidGlobalContext();
1403 EVENT("glProgramUniformMatrix2x4fv",
1404 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
1405 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
1406 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1407
1408 if (context)
1409 {
1410 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1411 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1412 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1413 bool isCallValid = (context->skipValidation() ||
1414 ValidateProgramUniformMatrix2x4fv(
1415 context, programPacked, locationPacked, count, transpose, value));
1416 if (isCallValid)
1417 {
1418 context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose,
1419 value);
1420 }
1421 ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, isCallValid, context, programPacked,
1422 locationPacked, count, transpose, value);
1423 }
1424 }
1425
ProgramUniformMatrix3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1426 void GL_APIENTRY ProgramUniformMatrix3fv(GLuint program,
1427 GLint location,
1428 GLsizei count,
1429 GLboolean transpose,
1430 const GLfloat *value)
1431 {
1432 Context *context = GetValidGlobalContext();
1433 EVENT("glProgramUniformMatrix3fv",
1434 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
1435 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
1436 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1437
1438 if (context)
1439 {
1440 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1441 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1442 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1443 bool isCallValid = (context->skipValidation() ||
1444 ValidateProgramUniformMatrix3fv(context, programPacked, locationPacked,
1445 count, transpose, value));
1446 if (isCallValid)
1447 {
1448 context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose,
1449 value);
1450 }
1451 ANGLE_CAPTURE(ProgramUniformMatrix3fv, isCallValid, context, programPacked, locationPacked,
1452 count, transpose, value);
1453 }
1454 }
1455
ProgramUniformMatrix3x2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1456 void GL_APIENTRY ProgramUniformMatrix3x2fv(GLuint program,
1457 GLint location,
1458 GLsizei count,
1459 GLboolean transpose,
1460 const GLfloat *value)
1461 {
1462 Context *context = GetValidGlobalContext();
1463 EVENT("glProgramUniformMatrix3x2fv",
1464 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
1465 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
1466 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1467
1468 if (context)
1469 {
1470 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1471 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1472 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1473 bool isCallValid = (context->skipValidation() ||
1474 ValidateProgramUniformMatrix3x2fv(
1475 context, programPacked, locationPacked, count, transpose, value));
1476 if (isCallValid)
1477 {
1478 context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose,
1479 value);
1480 }
1481 ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, isCallValid, context, programPacked,
1482 locationPacked, count, transpose, value);
1483 }
1484 }
1485
ProgramUniformMatrix3x4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1486 void GL_APIENTRY ProgramUniformMatrix3x4fv(GLuint program,
1487 GLint location,
1488 GLsizei count,
1489 GLboolean transpose,
1490 const GLfloat *value)
1491 {
1492 Context *context = GetValidGlobalContext();
1493 EVENT("glProgramUniformMatrix3x4fv",
1494 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
1495 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
1496 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1497
1498 if (context)
1499 {
1500 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1501 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1502 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1503 bool isCallValid = (context->skipValidation() ||
1504 ValidateProgramUniformMatrix3x4fv(
1505 context, programPacked, locationPacked, count, transpose, value));
1506 if (isCallValid)
1507 {
1508 context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose,
1509 value);
1510 }
1511 ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, isCallValid, context, programPacked,
1512 locationPacked, count, transpose, value);
1513 }
1514 }
1515
ProgramUniformMatrix4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1516 void GL_APIENTRY ProgramUniformMatrix4fv(GLuint program,
1517 GLint location,
1518 GLsizei count,
1519 GLboolean transpose,
1520 const GLfloat *value)
1521 {
1522 Context *context = GetValidGlobalContext();
1523 EVENT("glProgramUniformMatrix4fv",
1524 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
1525 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
1526 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1527
1528 if (context)
1529 {
1530 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1531 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1532 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1533 bool isCallValid = (context->skipValidation() ||
1534 ValidateProgramUniformMatrix4fv(context, programPacked, locationPacked,
1535 count, transpose, value));
1536 if (isCallValid)
1537 {
1538 context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose,
1539 value);
1540 }
1541 ANGLE_CAPTURE(ProgramUniformMatrix4fv, isCallValid, context, programPacked, locationPacked,
1542 count, transpose, value);
1543 }
1544 }
1545
ProgramUniformMatrix4x2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1546 void GL_APIENTRY ProgramUniformMatrix4x2fv(GLuint program,
1547 GLint location,
1548 GLsizei count,
1549 GLboolean transpose,
1550 const GLfloat *value)
1551 {
1552 Context *context = GetValidGlobalContext();
1553 EVENT("glProgramUniformMatrix4x2fv",
1554 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
1555 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
1556 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1557
1558 if (context)
1559 {
1560 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1561 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1562 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1563 bool isCallValid = (context->skipValidation() ||
1564 ValidateProgramUniformMatrix4x2fv(
1565 context, programPacked, locationPacked, count, transpose, value));
1566 if (isCallValid)
1567 {
1568 context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose,
1569 value);
1570 }
1571 ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, isCallValid, context, programPacked,
1572 locationPacked, count, transpose, value);
1573 }
1574 }
1575
ProgramUniformMatrix4x3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1576 void GL_APIENTRY ProgramUniformMatrix4x3fv(GLuint program,
1577 GLint location,
1578 GLsizei count,
1579 GLboolean transpose,
1580 const GLfloat *value)
1581 {
1582 Context *context = GetValidGlobalContext();
1583 EVENT("glProgramUniformMatrix4x3fv",
1584 "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean "
1585 "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "",
1586 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1587
1588 if (context)
1589 {
1590 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1591 UniformLocation locationPacked = FromGL<UniformLocation>(location);
1592 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1593 bool isCallValid = (context->skipValidation() ||
1594 ValidateProgramUniformMatrix4x3fv(
1595 context, programPacked, locationPacked, count, transpose, value));
1596 if (isCallValid)
1597 {
1598 context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose,
1599 value);
1600 }
1601 ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, isCallValid, context, programPacked,
1602 locationPacked, count, transpose, value);
1603 }
1604 }
1605
SampleMaski(GLuint maskNumber,GLbitfield mask)1606 void GL_APIENTRY SampleMaski(GLuint maskNumber, GLbitfield mask)
1607 {
1608 Context *context = GetValidGlobalContext();
1609 EVENT("glSampleMaski", "context = %d, GLuint maskNumber = %u, GLbitfield mask = %s",
1610 CID(context), maskNumber, GLbitfieldToString(GLenumGroup::DefaultGroup, mask).c_str());
1611
1612 if (context)
1613 {
1614 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1615 bool isCallValid =
1616 (context->skipValidation() || ValidateSampleMaski(context, maskNumber, mask));
1617 if (isCallValid)
1618 {
1619 context->sampleMaski(maskNumber, mask);
1620 }
1621 ANGLE_CAPTURE(SampleMaski, isCallValid, context, maskNumber, mask);
1622 }
1623 }
1624
TexStorage2DMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)1625 void GL_APIENTRY TexStorage2DMultisample(GLenum target,
1626 GLsizei samples,
1627 GLenum internalformat,
1628 GLsizei width,
1629 GLsizei height,
1630 GLboolean fixedsamplelocations)
1631 {
1632 Context *context = GetValidGlobalContext();
1633 EVENT("glTexStorage2DMultisample",
1634 "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, "
1635 "GLsizei width = %d, GLsizei height = %d, GLboolean fixedsamplelocations = %s",
1636 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
1637 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height,
1638 GLbooleanToString(fixedsamplelocations));
1639
1640 if (context)
1641 {
1642 TextureType targetPacked = FromGL<TextureType>(target);
1643 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1644 bool isCallValid =
1645 (context->skipValidation() ||
1646 ValidateTexStorage2DMultisample(context, targetPacked, samples, internalformat, width,
1647 height, fixedsamplelocations));
1648 if (isCallValid)
1649 {
1650 context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height,
1651 fixedsamplelocations);
1652 }
1653 ANGLE_CAPTURE(TexStorage2DMultisample, isCallValid, context, targetPacked, samples,
1654 internalformat, width, height, fixedsamplelocations);
1655 }
1656 }
1657
UseProgramStages(GLuint pipeline,GLbitfield stages,GLuint program)1658 void GL_APIENTRY UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
1659 {
1660 Context *context = GetValidGlobalContext();
1661 EVENT("glUseProgramStages",
1662 "context = %d, GLuint pipeline = %u, GLbitfield stages = %s, GLuint program = %u",
1663 CID(context), pipeline,
1664 GLbitfieldToString(GLenumGroup::UseProgramStageMask, stages).c_str(), program);
1665
1666 if (context)
1667 {
1668 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
1669 ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
1670 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1671 bool isCallValid =
1672 (context->skipValidation() ||
1673 ValidateUseProgramStages(context, pipelinePacked, stages, programPacked));
1674 if (isCallValid)
1675 {
1676 context->useProgramStages(pipelinePacked, stages, programPacked);
1677 }
1678 ANGLE_CAPTURE(UseProgramStages, isCallValid, context, pipelinePacked, stages,
1679 programPacked);
1680 }
1681 }
1682
ValidateProgramPipeline(GLuint pipeline)1683 void GL_APIENTRY ValidateProgramPipeline(GLuint pipeline)
1684 {
1685 Context *context = GetValidGlobalContext();
1686 EVENT("glValidateProgramPipeline", "context = %d, GLuint pipeline = %u", CID(context),
1687 pipeline);
1688
1689 if (context)
1690 {
1691 ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline);
1692 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1693 bool isCallValid =
1694 (context->skipValidation() || ValidateValidateProgramPipeline(context, pipelinePacked));
1695 if (isCallValid)
1696 {
1697 context->validateProgramPipeline(pipelinePacked);
1698 }
1699 ANGLE_CAPTURE(ValidateProgramPipeline, isCallValid, context, pipelinePacked);
1700 }
1701 }
1702
VertexAttribBinding(GLuint attribindex,GLuint bindingindex)1703 void GL_APIENTRY VertexAttribBinding(GLuint attribindex, GLuint bindingindex)
1704 {
1705 Context *context = GetValidGlobalContext();
1706 EVENT("glVertexAttribBinding",
1707 "context = %d, GLuint attribindex = %u, GLuint bindingindex = %u", CID(context),
1708 attribindex, bindingindex);
1709
1710 if (context)
1711 {
1712 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1713 bool isCallValid = (context->skipValidation() ||
1714 ValidateVertexAttribBinding(context, attribindex, bindingindex));
1715 if (isCallValid)
1716 {
1717 context->vertexAttribBinding(attribindex, bindingindex);
1718 }
1719 ANGLE_CAPTURE(VertexAttribBinding, isCallValid, context, attribindex, bindingindex);
1720 }
1721 }
1722
VertexAttribFormat(GLuint attribindex,GLint size,GLenum type,GLboolean normalized,GLuint relativeoffset)1723 void GL_APIENTRY VertexAttribFormat(GLuint attribindex,
1724 GLint size,
1725 GLenum type,
1726 GLboolean normalized,
1727 GLuint relativeoffset)
1728 {
1729 Context *context = GetValidGlobalContext();
1730 EVENT("glVertexAttribFormat",
1731 "context = %d, GLuint attribindex = %u, GLint size = %d, GLenum type = %s, GLboolean "
1732 "normalized = %s, GLuint relativeoffset = %u",
1733 CID(context), attribindex, size, GLenumToString(GLenumGroup::DefaultGroup, type),
1734 GLbooleanToString(normalized), relativeoffset);
1735
1736 if (context)
1737 {
1738 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
1739 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1740 bool isCallValid = (context->skipValidation() ||
1741 ValidateVertexAttribFormat(context, attribindex, size, typePacked,
1742 normalized, relativeoffset));
1743 if (isCallValid)
1744 {
1745 context->vertexAttribFormat(attribindex, size, typePacked, normalized, relativeoffset);
1746 }
1747 ANGLE_CAPTURE(VertexAttribFormat, isCallValid, context, attribindex, size, typePacked,
1748 normalized, relativeoffset);
1749 }
1750 }
1751
VertexAttribIFormat(GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset)1752 void GL_APIENTRY VertexAttribIFormat(GLuint attribindex,
1753 GLint size,
1754 GLenum type,
1755 GLuint relativeoffset)
1756 {
1757 Context *context = GetValidGlobalContext();
1758 EVENT("glVertexAttribIFormat",
1759 "context = %d, GLuint attribindex = %u, GLint size = %d, GLenum type = %s, GLuint "
1760 "relativeoffset = %u",
1761 CID(context), attribindex, size, GLenumToString(GLenumGroup::DefaultGroup, type),
1762 relativeoffset);
1763
1764 if (context)
1765 {
1766 VertexAttribType typePacked = FromGL<VertexAttribType>(type);
1767 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1768 bool isCallValid =
1769 (context->skipValidation() ||
1770 ValidateVertexAttribIFormat(context, attribindex, size, typePacked, relativeoffset));
1771 if (isCallValid)
1772 {
1773 context->vertexAttribIFormat(attribindex, size, typePacked, relativeoffset);
1774 }
1775 ANGLE_CAPTURE(VertexAttribIFormat, isCallValid, context, attribindex, size, typePacked,
1776 relativeoffset);
1777 }
1778 }
1779
VertexBindingDivisor(GLuint bindingindex,GLuint divisor)1780 void GL_APIENTRY VertexBindingDivisor(GLuint bindingindex, GLuint divisor)
1781 {
1782 Context *context = GetValidGlobalContext();
1783 EVENT("glVertexBindingDivisor", "context = %d, GLuint bindingindex = %u, GLuint divisor = %u",
1784 CID(context), bindingindex, divisor);
1785
1786 if (context)
1787 {
1788 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
1789 bool isCallValid = (context->skipValidation() ||
1790 ValidateVertexBindingDivisor(context, bindingindex, divisor));
1791 if (isCallValid)
1792 {
1793 context->vertexBindingDivisor(bindingindex, divisor);
1794 }
1795 ANGLE_CAPTURE(VertexBindingDivisor, isCallValid, context, bindingindex, divisor);
1796 }
1797 }
1798 } // namespace gl
1799