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 "common/entry_points_enum_autogen.h"
14 #include "libANGLE/Context.h"
15 #include "libANGLE/Context.inl.h"
16 #include "libANGLE/capture/capture_gles_3_1_autogen.h"
17 #include "libANGLE/capture/gl_enum_utils.h"
18 #include "libANGLE/entry_points_utils.h"
19 #include "libANGLE/validationES31.h"
20 #include "libGLESv2/global_state.h"
21
22 using namespace gl;
23
24 extern "C" {
GL_ActiveShaderProgram(GLuint pipeline,GLuint program)25 void GL_APIENTRY GL_ActiveShaderProgram(GLuint pipeline, GLuint program)
26 {
27 Context *context = GetValidGlobalContext();
28 EVENT(context, GLActiveShaderProgram, "context = %d, pipeline = %u, program = %u", CID(context),
29 pipeline, program);
30
31 if (context)
32 {
33 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
34 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
35 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
36 bool isCallValid =
37 (context->skipValidation() ||
38 ValidateActiveShaderProgram(context, angle::EntryPoint::GLActiveShaderProgram,
39 pipelinePacked, programPacked));
40 if (isCallValid)
41 {
42 context->activeShaderProgram(pipelinePacked, programPacked);
43 }
44 ANGLE_CAPTURE(ActiveShaderProgram, isCallValid, context, pipelinePacked, programPacked);
45 }
46 else
47 {
48 GenerateContextLostErrorOnCurrentGlobalContext();
49 }
50 }
51
GL_BindImageTexture(GLuint unit,GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum access,GLenum format)52 void GL_APIENTRY GL_BindImageTexture(GLuint unit,
53 GLuint texture,
54 GLint level,
55 GLboolean layered,
56 GLint layer,
57 GLenum access,
58 GLenum format)
59 {
60 Context *context = GetValidGlobalContext();
61 EVENT(context, GLBindImageTexture,
62 "context = %d, unit = %u, texture = %u, level = %d, layered = %s, layer = %d, access = "
63 "%s, format = %s",
64 CID(context), unit, texture, level, GLbooleanToString(layered), layer,
65 GLenumToString(GLenumGroup::BufferAccessARB, access),
66 GLenumToString(GLenumGroup::InternalFormat, format));
67
68 if (context)
69 {
70 TextureID texturePacked = PackParam<TextureID>(texture);
71 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
72 bool isCallValid =
73 (context->skipValidation() ||
74 ValidateBindImageTexture(context, angle::EntryPoint::GLBindImageTexture, unit,
75 texturePacked, level, layered, layer, access, format));
76 if (isCallValid)
77 {
78 context->bindImageTexture(unit, texturePacked, level, layered, layer, access, format);
79 }
80 ANGLE_CAPTURE(BindImageTexture, isCallValid, context, unit, texturePacked, level, layered,
81 layer, access, format);
82 }
83 else
84 {
85 GenerateContextLostErrorOnCurrentGlobalContext();
86 }
87 }
88
GL_BindProgramPipeline(GLuint pipeline)89 void GL_APIENTRY GL_BindProgramPipeline(GLuint pipeline)
90 {
91 Context *context = GetValidGlobalContext();
92 EVENT(context, GLBindProgramPipeline, "context = %d, pipeline = %u", CID(context), pipeline);
93
94 if (context)
95 {
96 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
97 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
98 bool isCallValid = (context->skipValidation() ||
99 ValidateBindProgramPipeline(
100 context, angle::EntryPoint::GLBindProgramPipeline, pipelinePacked));
101 if (isCallValid)
102 {
103 context->bindProgramPipeline(pipelinePacked);
104 }
105 ANGLE_CAPTURE(BindProgramPipeline, isCallValid, context, pipelinePacked);
106 }
107 else
108 {
109 GenerateContextLostErrorOnCurrentGlobalContext();
110 }
111 }
112
GL_BindVertexBuffer(GLuint bindingindex,GLuint buffer,GLintptr offset,GLsizei stride)113 void GL_APIENTRY GL_BindVertexBuffer(GLuint bindingindex,
114 GLuint buffer,
115 GLintptr offset,
116 GLsizei stride)
117 {
118 Context *context = GetValidGlobalContext();
119 EVENT(context, GLBindVertexBuffer,
120 "context = %d, bindingindex = %u, buffer = %u, offset = %llu, stride = %d", CID(context),
121 bindingindex, buffer, static_cast<unsigned long long>(offset), stride);
122
123 if (context)
124 {
125 BufferID bufferPacked = PackParam<BufferID>(buffer);
126 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
127 bool isCallValid = (context->skipValidation() ||
128 ValidateBindVertexBuffer(context, angle::EntryPoint::GLBindVertexBuffer,
129 bindingindex, bufferPacked, offset, stride));
130 if (isCallValid)
131 {
132 context->bindVertexBuffer(bindingindex, bufferPacked, offset, stride);
133 }
134 ANGLE_CAPTURE(BindVertexBuffer, isCallValid, context, bindingindex, bufferPacked, offset,
135 stride);
136 }
137 else
138 {
139 GenerateContextLostErrorOnCurrentGlobalContext();
140 }
141 }
142
GL_CreateShaderProgramv(GLenum type,GLsizei count,const GLchar * const * strings)143 GLuint GL_APIENTRY GL_CreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
144 {
145 Context *context = GetValidGlobalContext();
146 EVENT(context, GLCreateShaderProgramv,
147 "context = %d, type = %s, count = %d, strings = 0x%016" PRIxPTR "", CID(context),
148 GLenumToString(GLenumGroup::ShaderType, type), count, (uintptr_t)strings);
149
150 GLuint returnValue;
151 if (context)
152 {
153 ShaderType typePacked = PackParam<ShaderType>(type);
154 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
155 bool isCallValid =
156 (context->skipValidation() ||
157 ValidateCreateShaderProgramv(context, angle::EntryPoint::GLCreateShaderProgramv,
158 typePacked, count, strings));
159 if (isCallValid)
160 {
161 returnValue = context->createShaderProgramv(typePacked, count, strings);
162 }
163 else
164 {
165 returnValue =
166 GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramv, GLuint>();
167 }
168 ANGLE_CAPTURE(CreateShaderProgramv, isCallValid, context, typePacked, count, strings,
169 returnValue);
170 }
171 else
172 {
173 GenerateContextLostErrorOnCurrentGlobalContext();
174 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramv, GLuint>();
175 }
176 return returnValue;
177 }
178
GL_DeleteProgramPipelines(GLsizei n,const GLuint * pipelines)179 void GL_APIENTRY GL_DeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
180 {
181 Context *context = GetValidGlobalContext();
182 EVENT(context, GLDeleteProgramPipelines, "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "",
183 CID(context), n, (uintptr_t)pipelines);
184
185 if (context)
186 {
187 const ProgramPipelineID *pipelinesPacked = PackParam<const ProgramPipelineID *>(pipelines);
188 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
189 bool isCallValid =
190 (context->skipValidation() ||
191 ValidateDeleteProgramPipelines(context, angle::EntryPoint::GLDeleteProgramPipelines, n,
192 pipelinesPacked));
193 if (isCallValid)
194 {
195 context->deleteProgramPipelines(n, pipelinesPacked);
196 }
197 ANGLE_CAPTURE(DeleteProgramPipelines, isCallValid, context, n, pipelinesPacked);
198 }
199 else
200 {
201 GenerateContextLostErrorOnCurrentGlobalContext();
202 }
203 }
204
GL_DispatchCompute(GLuint num_groups_x,GLuint num_groups_y,GLuint num_groups_z)205 void GL_APIENTRY GL_DispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
206 {
207 Context *context = GetValidGlobalContext();
208 EVENT(context, GLDispatchCompute,
209 "context = %d, num_groups_x = %u, num_groups_y = %u, num_groups_z = %u", CID(context),
210 num_groups_x, num_groups_y, num_groups_z);
211
212 if (context)
213 {
214 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
215 bool isCallValid = (context->skipValidation() ||
216 ValidateDispatchCompute(context, angle::EntryPoint::GLDispatchCompute,
217 num_groups_x, num_groups_y, num_groups_z));
218 if (isCallValid)
219 {
220 context->dispatchCompute(num_groups_x, num_groups_y, num_groups_z);
221 }
222 ANGLE_CAPTURE(DispatchCompute, isCallValid, context, num_groups_x, num_groups_y,
223 num_groups_z);
224 }
225 else
226 {
227 GenerateContextLostErrorOnCurrentGlobalContext();
228 }
229 }
230
GL_DispatchComputeIndirect(GLintptr indirect)231 void GL_APIENTRY GL_DispatchComputeIndirect(GLintptr indirect)
232 {
233 Context *context = GetValidGlobalContext();
234 EVENT(context, GLDispatchComputeIndirect, "context = %d, indirect = %llu", CID(context),
235 static_cast<unsigned long long>(indirect));
236
237 if (context)
238 {
239 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
240 bool isCallValid = (context->skipValidation() ||
241 ValidateDispatchComputeIndirect(
242 context, angle::EntryPoint::GLDispatchComputeIndirect, indirect));
243 if (isCallValid)
244 {
245 context->dispatchComputeIndirect(indirect);
246 }
247 ANGLE_CAPTURE(DispatchComputeIndirect, isCallValid, context, indirect);
248 }
249 else
250 {
251 GenerateContextLostErrorOnCurrentGlobalContext();
252 }
253 }
254
GL_DrawArraysIndirect(GLenum mode,const void * indirect)255 void GL_APIENTRY GL_DrawArraysIndirect(GLenum mode, const void *indirect)
256 {
257 Context *context = GetValidGlobalContext();
258 EVENT(context, GLDrawArraysIndirect, "context = %d, mode = %s, indirect = 0x%016" PRIxPTR "",
259 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)indirect);
260
261 if (context)
262 {
263 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
264 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
265 bool isCallValid =
266 (context->skipValidation() ||
267 ValidateDrawArraysIndirect(context, angle::EntryPoint::GLDrawArraysIndirect,
268 modePacked, indirect));
269 if (isCallValid)
270 {
271 context->drawArraysIndirect(modePacked, indirect);
272 }
273 ANGLE_CAPTURE(DrawArraysIndirect, isCallValid, context, modePacked, indirect);
274 }
275 else
276 {
277 GenerateContextLostErrorOnCurrentGlobalContext();
278 }
279 }
280
GL_DrawElementsIndirect(GLenum mode,GLenum type,const void * indirect)281 void GL_APIENTRY GL_DrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
282 {
283 Context *context = GetValidGlobalContext();
284 EVENT(context, GLDrawElementsIndirect,
285 "context = %d, mode = %s, type = %s, indirect = 0x%016" PRIxPTR "", CID(context),
286 GLenumToString(GLenumGroup::PrimitiveType, mode),
287 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indirect);
288
289 if (context)
290 {
291 PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
292 DrawElementsType typePacked = PackParam<DrawElementsType>(type);
293 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
294 bool isCallValid =
295 (context->skipValidation() ||
296 ValidateDrawElementsIndirect(context, angle::EntryPoint::GLDrawElementsIndirect,
297 modePacked, typePacked, indirect));
298 if (isCallValid)
299 {
300 context->drawElementsIndirect(modePacked, typePacked, indirect);
301 }
302 ANGLE_CAPTURE(DrawElementsIndirect, isCallValid, context, modePacked, typePacked, indirect);
303 }
304 else
305 {
306 GenerateContextLostErrorOnCurrentGlobalContext();
307 }
308 }
309
GL_FramebufferParameteri(GLenum target,GLenum pname,GLint param)310 void GL_APIENTRY GL_FramebufferParameteri(GLenum target, GLenum pname, GLint param)
311 {
312 Context *context = GetValidGlobalContext();
313 EVENT(context, GLFramebufferParameteri, "context = %d, target = %s, pname = %s, param = %d",
314 CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target),
315 GLenumToString(GLenumGroup::FramebufferParameterName, pname), param);
316
317 if (context)
318 {
319 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
320 bool isCallValid =
321 (context->skipValidation() ||
322 ValidateFramebufferParameteri(context, angle::EntryPoint::GLFramebufferParameteri,
323 target, pname, param));
324 if (isCallValid)
325 {
326 context->framebufferParameteri(target, pname, param);
327 }
328 ANGLE_CAPTURE(FramebufferParameteri, isCallValid, context, target, pname, param);
329 }
330 else
331 {
332 GenerateContextLostErrorOnCurrentGlobalContext();
333 }
334 }
335
GL_GenProgramPipelines(GLsizei n,GLuint * pipelines)336 void GL_APIENTRY GL_GenProgramPipelines(GLsizei n, GLuint *pipelines)
337 {
338 Context *context = GetValidGlobalContext();
339 EVENT(context, GLGenProgramPipelines, "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "",
340 CID(context), n, (uintptr_t)pipelines);
341
342 if (context)
343 {
344 ProgramPipelineID *pipelinesPacked = PackParam<ProgramPipelineID *>(pipelines);
345 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
346 bool isCallValid =
347 (context->skipValidation() ||
348 ValidateGenProgramPipelines(context, angle::EntryPoint::GLGenProgramPipelines, n,
349 pipelinesPacked));
350 if (isCallValid)
351 {
352 context->genProgramPipelines(n, pipelinesPacked);
353 }
354 ANGLE_CAPTURE(GenProgramPipelines, isCallValid, context, n, pipelinesPacked);
355 }
356 else
357 {
358 GenerateContextLostErrorOnCurrentGlobalContext();
359 }
360 }
361
GL_GetBooleani_v(GLenum target,GLuint index,GLboolean * data)362 void GL_APIENTRY GL_GetBooleani_v(GLenum target, GLuint index, GLboolean *data)
363 {
364 Context *context = GetValidGlobalContext();
365 EVENT(context, GLGetBooleani_v,
366 "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context),
367 GLenumToString(GLenumGroup::BufferTargetARB, target), index, (uintptr_t)data);
368
369 if (context)
370 {
371 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
372 bool isCallValid = (context->skipValidation() ||
373 ValidateGetBooleani_v(context, angle::EntryPoint::GLGetBooleani_v,
374 target, index, data));
375 if (isCallValid)
376 {
377 context->getBooleani_v(target, index, data);
378 }
379 ANGLE_CAPTURE(GetBooleani_v, isCallValid, context, target, index, data);
380 }
381 else
382 {
383 GenerateContextLostErrorOnCurrentGlobalContext();
384 }
385 }
386
GL_GetFramebufferParameteriv(GLenum target,GLenum pname,GLint * params)387 void GL_APIENTRY GL_GetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
388 {
389 Context *context = GetValidGlobalContext();
390 EVENT(context, GLGetFramebufferParameteriv,
391 "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
392 GLenumToString(GLenumGroup::FramebufferTarget, target),
393 GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname),
394 (uintptr_t)params);
395
396 if (context)
397 {
398 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
399 bool isCallValid =
400 (context->skipValidation() ||
401 ValidateGetFramebufferParameteriv(
402 context, angle::EntryPoint::GLGetFramebufferParameteriv, target, pname, params));
403 if (isCallValid)
404 {
405 context->getFramebufferParameteriv(target, pname, params);
406 }
407 ANGLE_CAPTURE(GetFramebufferParameteriv, isCallValid, context, target, pname, params);
408 }
409 else
410 {
411 GenerateContextLostErrorOnCurrentGlobalContext();
412 }
413 }
414
GL_GetMultisamplefv(GLenum pname,GLuint index,GLfloat * val)415 void GL_APIENTRY GL_GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
416 {
417 Context *context = GetValidGlobalContext();
418 EVENT(context, GLGetMultisamplefv,
419 "context = %d, pname = %s, index = %u, val = 0x%016" PRIxPTR "", CID(context),
420 GLenumToString(GLenumGroup::DefaultGroup, pname), index, (uintptr_t)val);
421
422 if (context)
423 {
424 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
425 bool isCallValid = (context->skipValidation() ||
426 ValidateGetMultisamplefv(context, angle::EntryPoint::GLGetMultisamplefv,
427 pname, index, val));
428 if (isCallValid)
429 {
430 context->getMultisamplefv(pname, index, val);
431 }
432 ANGLE_CAPTURE(GetMultisamplefv, isCallValid, context, pname, index, val);
433 }
434 else
435 {
436 GenerateContextLostErrorOnCurrentGlobalContext();
437 }
438 }
439
GL_GetProgramInterfaceiv(GLuint program,GLenum programInterface,GLenum pname,GLint * params)440 void GL_APIENTRY GL_GetProgramInterfaceiv(GLuint program,
441 GLenum programInterface,
442 GLenum pname,
443 GLint *params)
444 {
445 Context *context = GetValidGlobalContext();
446 EVENT(context, GLGetProgramInterfaceiv,
447 "context = %d, program = %u, programInterface = %s, pname = %s, params = 0x%016" PRIxPTR
448 "",
449 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
450 GLenumToString(GLenumGroup::ProgramInterfacePName, pname), (uintptr_t)params);
451
452 if (context)
453 {
454 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
455 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
456 bool isCallValid =
457 (context->skipValidation() ||
458 ValidateGetProgramInterfaceiv(context, angle::EntryPoint::GLGetProgramInterfaceiv,
459 programPacked, programInterface, pname, params));
460 if (isCallValid)
461 {
462 context->getProgramInterfaceiv(programPacked, programInterface, pname, params);
463 }
464 ANGLE_CAPTURE(GetProgramInterfaceiv, isCallValid, context, programPacked, programInterface,
465 pname, params);
466 }
467 else
468 {
469 GenerateContextLostErrorOnCurrentGlobalContext();
470 }
471 }
472
GL_GetProgramPipelineInfoLog(GLuint pipeline,GLsizei bufSize,GLsizei * length,GLchar * infoLog)473 void GL_APIENTRY GL_GetProgramPipelineInfoLog(GLuint pipeline,
474 GLsizei bufSize,
475 GLsizei *length,
476 GLchar *infoLog)
477 {
478 Context *context = GetValidGlobalContext();
479 EVENT(context, GLGetProgramPipelineInfoLog,
480 "context = %d, pipeline = %u, bufSize = %d, length = 0x%016" PRIxPTR
481 ", infoLog = 0x%016" PRIxPTR "",
482 CID(context), pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
483
484 if (context)
485 {
486 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
487 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
488 bool isCallValid = (context->skipValidation() ||
489 ValidateGetProgramPipelineInfoLog(
490 context, angle::EntryPoint::GLGetProgramPipelineInfoLog,
491 pipelinePacked, bufSize, length, infoLog));
492 if (isCallValid)
493 {
494 context->getProgramPipelineInfoLog(pipelinePacked, bufSize, length, infoLog);
495 }
496 ANGLE_CAPTURE(GetProgramPipelineInfoLog, isCallValid, context, pipelinePacked, bufSize,
497 length, infoLog);
498 }
499 else
500 {
501 GenerateContextLostErrorOnCurrentGlobalContext();
502 }
503 }
504
GL_GetProgramPipelineiv(GLuint pipeline,GLenum pname,GLint * params)505 void GL_APIENTRY GL_GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
506 {
507 Context *context = GetValidGlobalContext();
508 EVENT(context, GLGetProgramPipelineiv,
509 "context = %d, pipeline = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
510 pipeline, GLenumToString(GLenumGroup::PipelineParameterName, pname), (uintptr_t)params);
511
512 if (context)
513 {
514 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
515 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
516 bool isCallValid =
517 (context->skipValidation() ||
518 ValidateGetProgramPipelineiv(context, angle::EntryPoint::GLGetProgramPipelineiv,
519 pipelinePacked, pname, params));
520 if (isCallValid)
521 {
522 context->getProgramPipelineiv(pipelinePacked, pname, params);
523 }
524 ANGLE_CAPTURE(GetProgramPipelineiv, isCallValid, context, pipelinePacked, pname, params);
525 }
526 else
527 {
528 GenerateContextLostErrorOnCurrentGlobalContext();
529 }
530 }
531
GL_GetProgramResourceIndex(GLuint program,GLenum programInterface,const GLchar * name)532 GLuint GL_APIENTRY GL_GetProgramResourceIndex(GLuint program,
533 GLenum programInterface,
534 const GLchar *name)
535 {
536 Context *context = GetValidGlobalContext();
537 EVENT(context, GLGetProgramResourceIndex,
538 "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "",
539 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
540 (uintptr_t)name);
541
542 GLuint returnValue;
543 if (context)
544 {
545 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
546 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
547 bool isCallValid =
548 (context->skipValidation() ||
549 ValidateGetProgramResourceIndex(context, angle::EntryPoint::GLGetProgramResourceIndex,
550 programPacked, programInterface, name));
551 if (isCallValid)
552 {
553 returnValue = context->getProgramResourceIndex(programPacked, programInterface, name);
554 }
555 else
556 {
557 returnValue =
558 GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceIndex, GLuint>();
559 }
560 ANGLE_CAPTURE(GetProgramResourceIndex, isCallValid, context, programPacked,
561 programInterface, name, returnValue);
562 }
563 else
564 {
565 GenerateContextLostErrorOnCurrentGlobalContext();
566 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceIndex, GLuint>();
567 }
568 return returnValue;
569 }
570
GL_GetProgramResourceLocation(GLuint program,GLenum programInterface,const GLchar * name)571 GLint GL_APIENTRY GL_GetProgramResourceLocation(GLuint program,
572 GLenum programInterface,
573 const GLchar *name)
574 {
575 Context *context = GetValidGlobalContext();
576 EVENT(context, GLGetProgramResourceLocation,
577 "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "",
578 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
579 (uintptr_t)name);
580
581 GLint returnValue;
582 if (context)
583 {
584 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
585 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
586 bool isCallValid = (context->skipValidation() ||
587 ValidateGetProgramResourceLocation(
588 context, angle::EntryPoint::GLGetProgramResourceLocation,
589 programPacked, programInterface, name));
590 if (isCallValid)
591 {
592 returnValue =
593 context->getProgramResourceLocation(programPacked, programInterface, name);
594 }
595 else
596 {
597 returnValue =
598 GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocation, GLint>();
599 }
600 ANGLE_CAPTURE(GetProgramResourceLocation, isCallValid, context, programPacked,
601 programInterface, name, returnValue);
602 }
603 else
604 {
605 GenerateContextLostErrorOnCurrentGlobalContext();
606 returnValue =
607 GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocation, GLint>();
608 }
609 return returnValue;
610 }
611
GL_GetProgramResourceName(GLuint program,GLenum programInterface,GLuint index,GLsizei bufSize,GLsizei * length,GLchar * name)612 void GL_APIENTRY GL_GetProgramResourceName(GLuint program,
613 GLenum programInterface,
614 GLuint index,
615 GLsizei bufSize,
616 GLsizei *length,
617 GLchar *name)
618 {
619 Context *context = GetValidGlobalContext();
620 EVENT(context, GLGetProgramResourceName,
621 "context = %d, program = %u, programInterface = %s, index = %u, bufSize = %d, length = "
622 "0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "",
623 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
624 index, bufSize, (uintptr_t)length, (uintptr_t)name);
625
626 if (context)
627 {
628 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
629 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
630 bool isCallValid = (context->skipValidation() ||
631 ValidateGetProgramResourceName(
632 context, angle::EntryPoint::GLGetProgramResourceName, programPacked,
633 programInterface, index, bufSize, length, name));
634 if (isCallValid)
635 {
636 context->getProgramResourceName(programPacked, programInterface, index, bufSize, length,
637 name);
638 }
639 ANGLE_CAPTURE(GetProgramResourceName, isCallValid, context, programPacked, programInterface,
640 index, bufSize, length, name);
641 }
642 else
643 {
644 GenerateContextLostErrorOnCurrentGlobalContext();
645 }
646 }
647
GL_GetProgramResourceiv(GLuint program,GLenum programInterface,GLuint index,GLsizei propCount,const GLenum * props,GLsizei bufSize,GLsizei * length,GLint * params)648 void GL_APIENTRY GL_GetProgramResourceiv(GLuint program,
649 GLenum programInterface,
650 GLuint index,
651 GLsizei propCount,
652 const GLenum *props,
653 GLsizei bufSize,
654 GLsizei *length,
655 GLint *params)
656 {
657 Context *context = GetValidGlobalContext();
658 EVENT(context, GLGetProgramResourceiv,
659 "context = %d, program = %u, programInterface = %s, index = %u, propCount = %d, props = "
660 "0x%016" PRIxPTR ", bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "",
661 CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface),
662 index, propCount, (uintptr_t)props, bufSize, (uintptr_t)length, (uintptr_t)params);
663
664 if (context)
665 {
666 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
667 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
668 bool isCallValid =
669 (context->skipValidation() ||
670 ValidateGetProgramResourceiv(context, angle::EntryPoint::GLGetProgramResourceiv,
671 programPacked, programInterface, index, propCount, props,
672 bufSize, length, params));
673 if (isCallValid)
674 {
675 context->getProgramResourceiv(programPacked, programInterface, index, propCount, props,
676 bufSize, length, params);
677 }
678 ANGLE_CAPTURE(GetProgramResourceiv, isCallValid, context, programPacked, programInterface,
679 index, propCount, props, bufSize, length, params);
680 }
681 else
682 {
683 GenerateContextLostErrorOnCurrentGlobalContext();
684 }
685 }
686
GL_GetTexLevelParameterfv(GLenum target,GLint level,GLenum pname,GLfloat * params)687 void GL_APIENTRY GL_GetTexLevelParameterfv(GLenum target,
688 GLint level,
689 GLenum pname,
690 GLfloat *params)
691 {
692 Context *context = GetValidGlobalContext();
693 EVENT(context, GLGetTexLevelParameterfv,
694 "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "",
695 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
696 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
697
698 if (context)
699 {
700 TextureTarget targetPacked = PackParam<TextureTarget>(target);
701 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
702 bool isCallValid =
703 (context->skipValidation() ||
704 ValidateGetTexLevelParameterfv(context, angle::EntryPoint::GLGetTexLevelParameterfv,
705 targetPacked, level, pname, params));
706 if (isCallValid)
707 {
708 context->getTexLevelParameterfv(targetPacked, level, pname, params);
709 }
710 ANGLE_CAPTURE(GetTexLevelParameterfv, isCallValid, context, targetPacked, level, pname,
711 params);
712 }
713 else
714 {
715 GenerateContextLostErrorOnCurrentGlobalContext();
716 }
717 }
718
GL_GetTexLevelParameteriv(GLenum target,GLint level,GLenum pname,GLint * params)719 void GL_APIENTRY GL_GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
720 {
721 Context *context = GetValidGlobalContext();
722 EVENT(context, GLGetTexLevelParameteriv,
723 "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "",
724 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
725 GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
726
727 if (context)
728 {
729 TextureTarget targetPacked = PackParam<TextureTarget>(target);
730 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
731 bool isCallValid =
732 (context->skipValidation() ||
733 ValidateGetTexLevelParameteriv(context, angle::EntryPoint::GLGetTexLevelParameteriv,
734 targetPacked, level, pname, params));
735 if (isCallValid)
736 {
737 context->getTexLevelParameteriv(targetPacked, level, pname, params);
738 }
739 ANGLE_CAPTURE(GetTexLevelParameteriv, isCallValid, context, targetPacked, level, pname,
740 params);
741 }
742 else
743 {
744 GenerateContextLostErrorOnCurrentGlobalContext();
745 }
746 }
747
GL_IsProgramPipeline(GLuint pipeline)748 GLboolean GL_APIENTRY GL_IsProgramPipeline(GLuint pipeline)
749 {
750 Context *context = GetValidGlobalContext();
751 EVENT(context, GLIsProgramPipeline, "context = %d, pipeline = %u", CID(context), pipeline);
752
753 GLboolean returnValue;
754 if (context)
755 {
756 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
757 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
758 bool isCallValid = (context->skipValidation() ||
759 ValidateIsProgramPipeline(
760 context, angle::EntryPoint::GLIsProgramPipeline, pipelinePacked));
761 if (isCallValid)
762 {
763 returnValue = context->isProgramPipeline(pipelinePacked);
764 }
765 else
766 {
767 returnValue =
768 GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipeline, GLboolean>();
769 }
770 ANGLE_CAPTURE(IsProgramPipeline, isCallValid, context, pipelinePacked, returnValue);
771 }
772 else
773 {
774 GenerateContextLostErrorOnCurrentGlobalContext();
775 returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipeline, GLboolean>();
776 }
777 return returnValue;
778 }
779
GL_MemoryBarrier(GLbitfield barriers)780 void GL_APIENTRY GL_MemoryBarrier(GLbitfield barriers)
781 {
782 Context *context = GetValidGlobalContext();
783 EVENT(context, GLMemoryBarrier, "context = %d, barriers = %s", CID(context),
784 GLbitfieldToString(GLenumGroup::MemoryBarrierMask, barriers).c_str());
785
786 if (context)
787 {
788 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
789 bool isCallValid =
790 (context->skipValidation() ||
791 ValidateMemoryBarrier(context, angle::EntryPoint::GLMemoryBarrier, barriers));
792 if (isCallValid)
793 {
794 context->memoryBarrier(barriers);
795 }
796 ANGLE_CAPTURE(MemoryBarrier, isCallValid, context, barriers);
797 }
798 else
799 {
800 GenerateContextLostErrorOnCurrentGlobalContext();
801 }
802 }
803
GL_MemoryBarrierByRegion(GLbitfield barriers)804 void GL_APIENTRY GL_MemoryBarrierByRegion(GLbitfield barriers)
805 {
806 Context *context = GetValidGlobalContext();
807 EVENT(context, GLMemoryBarrierByRegion, "context = %d, barriers = %s", CID(context),
808 GLbitfieldToString(GLenumGroup::MemoryBarrierMask, barriers).c_str());
809
810 if (context)
811 {
812 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
813 bool isCallValid = (context->skipValidation() ||
814 ValidateMemoryBarrierByRegion(
815 context, angle::EntryPoint::GLMemoryBarrierByRegion, barriers));
816 if (isCallValid)
817 {
818 context->memoryBarrierByRegion(barriers);
819 }
820 ANGLE_CAPTURE(MemoryBarrierByRegion, isCallValid, context, barriers);
821 }
822 else
823 {
824 GenerateContextLostErrorOnCurrentGlobalContext();
825 }
826 }
827
GL_ProgramUniform1f(GLuint program,GLint location,GLfloat v0)828 void GL_APIENTRY GL_ProgramUniform1f(GLuint program, GLint location, GLfloat v0)
829 {
830 Context *context = GetValidGlobalContext();
831 EVENT(context, GLProgramUniform1f, "context = %d, program = %u, location = %d, v0 = %f",
832 CID(context), program, location, v0);
833
834 if (context)
835 {
836 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
837 UniformLocation locationPacked = PackParam<UniformLocation>(location);
838 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
839 bool isCallValid = (context->skipValidation() ||
840 ValidateProgramUniform1f(context, angle::EntryPoint::GLProgramUniform1f,
841 programPacked, locationPacked, v0));
842 if (isCallValid)
843 {
844 context->programUniform1f(programPacked, locationPacked, v0);
845 }
846 ANGLE_CAPTURE(ProgramUniform1f, isCallValid, context, programPacked, locationPacked, v0);
847 }
848 else
849 {
850 GenerateContextLostErrorOnCurrentGlobalContext();
851 }
852 }
853
GL_ProgramUniform1fv(GLuint program,GLint location,GLsizei count,const GLfloat * value)854 void GL_APIENTRY GL_ProgramUniform1fv(GLuint program,
855 GLint location,
856 GLsizei count,
857 const GLfloat *value)
858 {
859 Context *context = GetValidGlobalContext();
860 EVENT(context, GLProgramUniform1fv,
861 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
862 CID(context), program, location, count, (uintptr_t)value);
863
864 if (context)
865 {
866 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
867 UniformLocation locationPacked = PackParam<UniformLocation>(location);
868 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
869 bool isCallValid =
870 (context->skipValidation() ||
871 ValidateProgramUniform1fv(context, angle::EntryPoint::GLProgramUniform1fv,
872 programPacked, locationPacked, count, value));
873 if (isCallValid)
874 {
875 context->programUniform1fv(programPacked, locationPacked, count, value);
876 }
877 ANGLE_CAPTURE(ProgramUniform1fv, isCallValid, context, programPacked, locationPacked, count,
878 value);
879 }
880 else
881 {
882 GenerateContextLostErrorOnCurrentGlobalContext();
883 }
884 }
885
GL_ProgramUniform1i(GLuint program,GLint location,GLint v0)886 void GL_APIENTRY GL_ProgramUniform1i(GLuint program, GLint location, GLint v0)
887 {
888 Context *context = GetValidGlobalContext();
889 EVENT(context, GLProgramUniform1i, "context = %d, program = %u, location = %d, v0 = %d",
890 CID(context), program, location, v0);
891
892 if (context)
893 {
894 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
895 UniformLocation locationPacked = PackParam<UniformLocation>(location);
896 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
897 bool isCallValid = (context->skipValidation() ||
898 ValidateProgramUniform1i(context, angle::EntryPoint::GLProgramUniform1i,
899 programPacked, locationPacked, v0));
900 if (isCallValid)
901 {
902 context->programUniform1i(programPacked, locationPacked, v0);
903 }
904 ANGLE_CAPTURE(ProgramUniform1i, isCallValid, context, programPacked, locationPacked, v0);
905 }
906 else
907 {
908 GenerateContextLostErrorOnCurrentGlobalContext();
909 }
910 }
911
GL_ProgramUniform1iv(GLuint program,GLint location,GLsizei count,const GLint * value)912 void GL_APIENTRY GL_ProgramUniform1iv(GLuint program,
913 GLint location,
914 GLsizei count,
915 const GLint *value)
916 {
917 Context *context = GetValidGlobalContext();
918 EVENT(context, GLProgramUniform1iv,
919 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
920 CID(context), program, location, count, (uintptr_t)value);
921
922 if (context)
923 {
924 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
925 UniformLocation locationPacked = PackParam<UniformLocation>(location);
926 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
927 bool isCallValid =
928 (context->skipValidation() ||
929 ValidateProgramUniform1iv(context, angle::EntryPoint::GLProgramUniform1iv,
930 programPacked, locationPacked, count, value));
931 if (isCallValid)
932 {
933 context->programUniform1iv(programPacked, locationPacked, count, value);
934 }
935 ANGLE_CAPTURE(ProgramUniform1iv, isCallValid, context, programPacked, locationPacked, count,
936 value);
937 }
938 else
939 {
940 GenerateContextLostErrorOnCurrentGlobalContext();
941 }
942 }
943
GL_ProgramUniform1ui(GLuint program,GLint location,GLuint v0)944 void GL_APIENTRY GL_ProgramUniform1ui(GLuint program, GLint location, GLuint v0)
945 {
946 Context *context = GetValidGlobalContext();
947 EVENT(context, GLProgramUniform1ui, "context = %d, program = %u, location = %d, v0 = %u",
948 CID(context), program, location, v0);
949
950 if (context)
951 {
952 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
953 UniformLocation locationPacked = PackParam<UniformLocation>(location);
954 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
955 bool isCallValid =
956 (context->skipValidation() ||
957 ValidateProgramUniform1ui(context, angle::EntryPoint::GLProgramUniform1ui,
958 programPacked, locationPacked, v0));
959 if (isCallValid)
960 {
961 context->programUniform1ui(programPacked, locationPacked, v0);
962 }
963 ANGLE_CAPTURE(ProgramUniform1ui, isCallValid, context, programPacked, locationPacked, v0);
964 }
965 else
966 {
967 GenerateContextLostErrorOnCurrentGlobalContext();
968 }
969 }
970
GL_ProgramUniform1uiv(GLuint program,GLint location,GLsizei count,const GLuint * value)971 void GL_APIENTRY GL_ProgramUniform1uiv(GLuint program,
972 GLint location,
973 GLsizei count,
974 const GLuint *value)
975 {
976 Context *context = GetValidGlobalContext();
977 EVENT(context, GLProgramUniform1uiv,
978 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
979 CID(context), program, location, count, (uintptr_t)value);
980
981 if (context)
982 {
983 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
984 UniformLocation locationPacked = PackParam<UniformLocation>(location);
985 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
986 bool isCallValid =
987 (context->skipValidation() ||
988 ValidateProgramUniform1uiv(context, angle::EntryPoint::GLProgramUniform1uiv,
989 programPacked, locationPacked, count, value));
990 if (isCallValid)
991 {
992 context->programUniform1uiv(programPacked, locationPacked, count, value);
993 }
994 ANGLE_CAPTURE(ProgramUniform1uiv, isCallValid, context, programPacked, locationPacked,
995 count, value);
996 }
997 else
998 {
999 GenerateContextLostErrorOnCurrentGlobalContext();
1000 }
1001 }
1002
GL_ProgramUniform2f(GLuint program,GLint location,GLfloat v0,GLfloat v1)1003 void GL_APIENTRY GL_ProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
1004 {
1005 Context *context = GetValidGlobalContext();
1006 EVENT(context, GLProgramUniform2f,
1007 "context = %d, program = %u, location = %d, v0 = %f, v1 = %f", CID(context), program,
1008 location, v0, v1);
1009
1010 if (context)
1011 {
1012 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1013 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1014 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1015 bool isCallValid = (context->skipValidation() ||
1016 ValidateProgramUniform2f(context, angle::EntryPoint::GLProgramUniform2f,
1017 programPacked, locationPacked, v0, v1));
1018 if (isCallValid)
1019 {
1020 context->programUniform2f(programPacked, locationPacked, v0, v1);
1021 }
1022 ANGLE_CAPTURE(ProgramUniform2f, isCallValid, context, programPacked, locationPacked, v0,
1023 v1);
1024 }
1025 else
1026 {
1027 GenerateContextLostErrorOnCurrentGlobalContext();
1028 }
1029 }
1030
GL_ProgramUniform2fv(GLuint program,GLint location,GLsizei count,const GLfloat * value)1031 void GL_APIENTRY GL_ProgramUniform2fv(GLuint program,
1032 GLint location,
1033 GLsizei count,
1034 const GLfloat *value)
1035 {
1036 Context *context = GetValidGlobalContext();
1037 EVENT(context, GLProgramUniform2fv,
1038 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
1039 CID(context), program, location, count, (uintptr_t)value);
1040
1041 if (context)
1042 {
1043 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1044 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1045 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1046 bool isCallValid =
1047 (context->skipValidation() ||
1048 ValidateProgramUniform2fv(context, angle::EntryPoint::GLProgramUniform2fv,
1049 programPacked, locationPacked, count, value));
1050 if (isCallValid)
1051 {
1052 context->programUniform2fv(programPacked, locationPacked, count, value);
1053 }
1054 ANGLE_CAPTURE(ProgramUniform2fv, isCallValid, context, programPacked, locationPacked, count,
1055 value);
1056 }
1057 else
1058 {
1059 GenerateContextLostErrorOnCurrentGlobalContext();
1060 }
1061 }
1062
GL_ProgramUniform2i(GLuint program,GLint location,GLint v0,GLint v1)1063 void GL_APIENTRY GL_ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
1064 {
1065 Context *context = GetValidGlobalContext();
1066 EVENT(context, GLProgramUniform2i,
1067 "context = %d, program = %u, location = %d, v0 = %d, v1 = %d", CID(context), program,
1068 location, v0, v1);
1069
1070 if (context)
1071 {
1072 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1073 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1074 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1075 bool isCallValid = (context->skipValidation() ||
1076 ValidateProgramUniform2i(context, angle::EntryPoint::GLProgramUniform2i,
1077 programPacked, locationPacked, v0, v1));
1078 if (isCallValid)
1079 {
1080 context->programUniform2i(programPacked, locationPacked, v0, v1);
1081 }
1082 ANGLE_CAPTURE(ProgramUniform2i, isCallValid, context, programPacked, locationPacked, v0,
1083 v1);
1084 }
1085 else
1086 {
1087 GenerateContextLostErrorOnCurrentGlobalContext();
1088 }
1089 }
1090
GL_ProgramUniform2iv(GLuint program,GLint location,GLsizei count,const GLint * value)1091 void GL_APIENTRY GL_ProgramUniform2iv(GLuint program,
1092 GLint location,
1093 GLsizei count,
1094 const GLint *value)
1095 {
1096 Context *context = GetValidGlobalContext();
1097 EVENT(context, GLProgramUniform2iv,
1098 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
1099 CID(context), program, location, count, (uintptr_t)value);
1100
1101 if (context)
1102 {
1103 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1104 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1105 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1106 bool isCallValid =
1107 (context->skipValidation() ||
1108 ValidateProgramUniform2iv(context, angle::EntryPoint::GLProgramUniform2iv,
1109 programPacked, locationPacked, count, value));
1110 if (isCallValid)
1111 {
1112 context->programUniform2iv(programPacked, locationPacked, count, value);
1113 }
1114 ANGLE_CAPTURE(ProgramUniform2iv, isCallValid, context, programPacked, locationPacked, count,
1115 value);
1116 }
1117 else
1118 {
1119 GenerateContextLostErrorOnCurrentGlobalContext();
1120 }
1121 }
1122
GL_ProgramUniform2ui(GLuint program,GLint location,GLuint v0,GLuint v1)1123 void GL_APIENTRY GL_ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
1124 {
1125 Context *context = GetValidGlobalContext();
1126 EVENT(context, GLProgramUniform2ui,
1127 "context = %d, program = %u, location = %d, v0 = %u, v1 = %u", CID(context), program,
1128 location, v0, v1);
1129
1130 if (context)
1131 {
1132 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1133 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1134 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1135 bool isCallValid =
1136 (context->skipValidation() ||
1137 ValidateProgramUniform2ui(context, angle::EntryPoint::GLProgramUniform2ui,
1138 programPacked, locationPacked, v0, v1));
1139 if (isCallValid)
1140 {
1141 context->programUniform2ui(programPacked, locationPacked, v0, v1);
1142 }
1143 ANGLE_CAPTURE(ProgramUniform2ui, isCallValid, context, programPacked, locationPacked, v0,
1144 v1);
1145 }
1146 else
1147 {
1148 GenerateContextLostErrorOnCurrentGlobalContext();
1149 }
1150 }
1151
GL_ProgramUniform2uiv(GLuint program,GLint location,GLsizei count,const GLuint * value)1152 void GL_APIENTRY GL_ProgramUniform2uiv(GLuint program,
1153 GLint location,
1154 GLsizei count,
1155 const GLuint *value)
1156 {
1157 Context *context = GetValidGlobalContext();
1158 EVENT(context, GLProgramUniform2uiv,
1159 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
1160 CID(context), program, location, count, (uintptr_t)value);
1161
1162 if (context)
1163 {
1164 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1165 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1166 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1167 bool isCallValid =
1168 (context->skipValidation() ||
1169 ValidateProgramUniform2uiv(context, angle::EntryPoint::GLProgramUniform2uiv,
1170 programPacked, locationPacked, count, value));
1171 if (isCallValid)
1172 {
1173 context->programUniform2uiv(programPacked, locationPacked, count, value);
1174 }
1175 ANGLE_CAPTURE(ProgramUniform2uiv, isCallValid, context, programPacked, locationPacked,
1176 count, value);
1177 }
1178 else
1179 {
1180 GenerateContextLostErrorOnCurrentGlobalContext();
1181 }
1182 }
1183
1184 void GL_APIENTRY
GL_ProgramUniform3f(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2)1185 GL_ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
1186 {
1187 Context *context = GetValidGlobalContext();
1188 EVENT(context, GLProgramUniform3f,
1189 "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f", CID(context),
1190 program, location, v0, v1, v2);
1191
1192 if (context)
1193 {
1194 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1195 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1196 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1197 bool isCallValid = (context->skipValidation() ||
1198 ValidateProgramUniform3f(context, angle::EntryPoint::GLProgramUniform3f,
1199 programPacked, locationPacked, v0, v1, v2));
1200 if (isCallValid)
1201 {
1202 context->programUniform3f(programPacked, locationPacked, v0, v1, v2);
1203 }
1204 ANGLE_CAPTURE(ProgramUniform3f, isCallValid, context, programPacked, locationPacked, v0, v1,
1205 v2);
1206 }
1207 else
1208 {
1209 GenerateContextLostErrorOnCurrentGlobalContext();
1210 }
1211 }
1212
GL_ProgramUniform3fv(GLuint program,GLint location,GLsizei count,const GLfloat * value)1213 void GL_APIENTRY GL_ProgramUniform3fv(GLuint program,
1214 GLint location,
1215 GLsizei count,
1216 const GLfloat *value)
1217 {
1218 Context *context = GetValidGlobalContext();
1219 EVENT(context, GLProgramUniform3fv,
1220 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
1221 CID(context), program, location, count, (uintptr_t)value);
1222
1223 if (context)
1224 {
1225 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1226 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1227 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1228 bool isCallValid =
1229 (context->skipValidation() ||
1230 ValidateProgramUniform3fv(context, angle::EntryPoint::GLProgramUniform3fv,
1231 programPacked, locationPacked, count, value));
1232 if (isCallValid)
1233 {
1234 context->programUniform3fv(programPacked, locationPacked, count, value);
1235 }
1236 ANGLE_CAPTURE(ProgramUniform3fv, isCallValid, context, programPacked, locationPacked, count,
1237 value);
1238 }
1239 else
1240 {
1241 GenerateContextLostErrorOnCurrentGlobalContext();
1242 }
1243 }
1244
GL_ProgramUniform3i(GLuint program,GLint location,GLint v0,GLint v1,GLint v2)1245 void GL_APIENTRY GL_ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
1246 {
1247 Context *context = GetValidGlobalContext();
1248 EVENT(context, GLProgramUniform3i,
1249 "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d", CID(context),
1250 program, location, v0, v1, v2);
1251
1252 if (context)
1253 {
1254 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1255 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1256 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1257 bool isCallValid = (context->skipValidation() ||
1258 ValidateProgramUniform3i(context, angle::EntryPoint::GLProgramUniform3i,
1259 programPacked, locationPacked, v0, v1, v2));
1260 if (isCallValid)
1261 {
1262 context->programUniform3i(programPacked, locationPacked, v0, v1, v2);
1263 }
1264 ANGLE_CAPTURE(ProgramUniform3i, isCallValid, context, programPacked, locationPacked, v0, v1,
1265 v2);
1266 }
1267 else
1268 {
1269 GenerateContextLostErrorOnCurrentGlobalContext();
1270 }
1271 }
1272
GL_ProgramUniform3iv(GLuint program,GLint location,GLsizei count,const GLint * value)1273 void GL_APIENTRY GL_ProgramUniform3iv(GLuint program,
1274 GLint location,
1275 GLsizei count,
1276 const GLint *value)
1277 {
1278 Context *context = GetValidGlobalContext();
1279 EVENT(context, GLProgramUniform3iv,
1280 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
1281 CID(context), program, location, count, (uintptr_t)value);
1282
1283 if (context)
1284 {
1285 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1286 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1287 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1288 bool isCallValid =
1289 (context->skipValidation() ||
1290 ValidateProgramUniform3iv(context, angle::EntryPoint::GLProgramUniform3iv,
1291 programPacked, locationPacked, count, value));
1292 if (isCallValid)
1293 {
1294 context->programUniform3iv(programPacked, locationPacked, count, value);
1295 }
1296 ANGLE_CAPTURE(ProgramUniform3iv, isCallValid, context, programPacked, locationPacked, count,
1297 value);
1298 }
1299 else
1300 {
1301 GenerateContextLostErrorOnCurrentGlobalContext();
1302 }
1303 }
1304
1305 void GL_APIENTRY
GL_ProgramUniform3ui(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2)1306 GL_ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
1307 {
1308 Context *context = GetValidGlobalContext();
1309 EVENT(context, GLProgramUniform3ui,
1310 "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u", CID(context),
1311 program, location, v0, v1, v2);
1312
1313 if (context)
1314 {
1315 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1316 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1317 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1318 bool isCallValid =
1319 (context->skipValidation() ||
1320 ValidateProgramUniform3ui(context, angle::EntryPoint::GLProgramUniform3ui,
1321 programPacked, locationPacked, v0, v1, v2));
1322 if (isCallValid)
1323 {
1324 context->programUniform3ui(programPacked, locationPacked, v0, v1, v2);
1325 }
1326 ANGLE_CAPTURE(ProgramUniform3ui, isCallValid, context, programPacked, locationPacked, v0,
1327 v1, v2);
1328 }
1329 else
1330 {
1331 GenerateContextLostErrorOnCurrentGlobalContext();
1332 }
1333 }
1334
GL_ProgramUniform3uiv(GLuint program,GLint location,GLsizei count,const GLuint * value)1335 void GL_APIENTRY GL_ProgramUniform3uiv(GLuint program,
1336 GLint location,
1337 GLsizei count,
1338 const GLuint *value)
1339 {
1340 Context *context = GetValidGlobalContext();
1341 EVENT(context, GLProgramUniform3uiv,
1342 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
1343 CID(context), program, location, count, (uintptr_t)value);
1344
1345 if (context)
1346 {
1347 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1348 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1349 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1350 bool isCallValid =
1351 (context->skipValidation() ||
1352 ValidateProgramUniform3uiv(context, angle::EntryPoint::GLProgramUniform3uiv,
1353 programPacked, locationPacked, count, value));
1354 if (isCallValid)
1355 {
1356 context->programUniform3uiv(programPacked, locationPacked, count, value);
1357 }
1358 ANGLE_CAPTURE(ProgramUniform3uiv, isCallValid, context, programPacked, locationPacked,
1359 count, value);
1360 }
1361 else
1362 {
1363 GenerateContextLostErrorOnCurrentGlobalContext();
1364 }
1365 }
1366
1367 void GL_APIENTRY
GL_ProgramUniform4f(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)1368 GL_ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
1369 {
1370 Context *context = GetValidGlobalContext();
1371 EVENT(context, GLProgramUniform4f,
1372 "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f",
1373 CID(context), program, location, v0, v1, v2, v3);
1374
1375 if (context)
1376 {
1377 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1378 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1379 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1380 bool isCallValid =
1381 (context->skipValidation() ||
1382 ValidateProgramUniform4f(context, angle::EntryPoint::GLProgramUniform4f, programPacked,
1383 locationPacked, v0, v1, v2, v3));
1384 if (isCallValid)
1385 {
1386 context->programUniform4f(programPacked, locationPacked, v0, v1, v2, v3);
1387 }
1388 ANGLE_CAPTURE(ProgramUniform4f, isCallValid, context, programPacked, locationPacked, v0, v1,
1389 v2, v3);
1390 }
1391 else
1392 {
1393 GenerateContextLostErrorOnCurrentGlobalContext();
1394 }
1395 }
1396
GL_ProgramUniform4fv(GLuint program,GLint location,GLsizei count,const GLfloat * value)1397 void GL_APIENTRY GL_ProgramUniform4fv(GLuint program,
1398 GLint location,
1399 GLsizei count,
1400 const GLfloat *value)
1401 {
1402 Context *context = GetValidGlobalContext();
1403 EVENT(context, GLProgramUniform4fv,
1404 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
1405 CID(context), program, location, count, (uintptr_t)value);
1406
1407 if (context)
1408 {
1409 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1410 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1411 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1412 bool isCallValid =
1413 (context->skipValidation() ||
1414 ValidateProgramUniform4fv(context, angle::EntryPoint::GLProgramUniform4fv,
1415 programPacked, locationPacked, count, value));
1416 if (isCallValid)
1417 {
1418 context->programUniform4fv(programPacked, locationPacked, count, value);
1419 }
1420 ANGLE_CAPTURE(ProgramUniform4fv, isCallValid, context, programPacked, locationPacked, count,
1421 value);
1422 }
1423 else
1424 {
1425 GenerateContextLostErrorOnCurrentGlobalContext();
1426 }
1427 }
1428
1429 void GL_APIENTRY
GL_ProgramUniform4i(GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3)1430 GL_ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
1431 {
1432 Context *context = GetValidGlobalContext();
1433 EVENT(context, GLProgramUniform4i,
1434 "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d, v3 = %d",
1435 CID(context), program, location, v0, v1, v2, v3);
1436
1437 if (context)
1438 {
1439 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1440 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1441 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1442 bool isCallValid =
1443 (context->skipValidation() ||
1444 ValidateProgramUniform4i(context, angle::EntryPoint::GLProgramUniform4i, programPacked,
1445 locationPacked, v0, v1, v2, v3));
1446 if (isCallValid)
1447 {
1448 context->programUniform4i(programPacked, locationPacked, v0, v1, v2, v3);
1449 }
1450 ANGLE_CAPTURE(ProgramUniform4i, isCallValid, context, programPacked, locationPacked, v0, v1,
1451 v2, v3);
1452 }
1453 else
1454 {
1455 GenerateContextLostErrorOnCurrentGlobalContext();
1456 }
1457 }
1458
GL_ProgramUniform4iv(GLuint program,GLint location,GLsizei count,const GLint * value)1459 void GL_APIENTRY GL_ProgramUniform4iv(GLuint program,
1460 GLint location,
1461 GLsizei count,
1462 const GLint *value)
1463 {
1464 Context *context = GetValidGlobalContext();
1465 EVENT(context, GLProgramUniform4iv,
1466 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
1467 CID(context), program, location, count, (uintptr_t)value);
1468
1469 if (context)
1470 {
1471 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1472 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1473 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1474 bool isCallValid =
1475 (context->skipValidation() ||
1476 ValidateProgramUniform4iv(context, angle::EntryPoint::GLProgramUniform4iv,
1477 programPacked, locationPacked, count, value));
1478 if (isCallValid)
1479 {
1480 context->programUniform4iv(programPacked, locationPacked, count, value);
1481 }
1482 ANGLE_CAPTURE(ProgramUniform4iv, isCallValid, context, programPacked, locationPacked, count,
1483 value);
1484 }
1485 else
1486 {
1487 GenerateContextLostErrorOnCurrentGlobalContext();
1488 }
1489 }
1490
1491 void GL_APIENTRY
GL_ProgramUniform4ui(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)1492 GL_ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
1493 {
1494 Context *context = GetValidGlobalContext();
1495 EVENT(context, GLProgramUniform4ui,
1496 "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u, v3 = %u",
1497 CID(context), program, location, v0, v1, v2, v3);
1498
1499 if (context)
1500 {
1501 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1502 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1503 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1504 bool isCallValid =
1505 (context->skipValidation() ||
1506 ValidateProgramUniform4ui(context, angle::EntryPoint::GLProgramUniform4ui,
1507 programPacked, locationPacked, v0, v1, v2, v3));
1508 if (isCallValid)
1509 {
1510 context->programUniform4ui(programPacked, locationPacked, v0, v1, v2, v3);
1511 }
1512 ANGLE_CAPTURE(ProgramUniform4ui, isCallValid, context, programPacked, locationPacked, v0,
1513 v1, v2, v3);
1514 }
1515 else
1516 {
1517 GenerateContextLostErrorOnCurrentGlobalContext();
1518 }
1519 }
1520
GL_ProgramUniform4uiv(GLuint program,GLint location,GLsizei count,const GLuint * value)1521 void GL_APIENTRY GL_ProgramUniform4uiv(GLuint program,
1522 GLint location,
1523 GLsizei count,
1524 const GLuint *value)
1525 {
1526 Context *context = GetValidGlobalContext();
1527 EVENT(context, GLProgramUniform4uiv,
1528 "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "",
1529 CID(context), program, location, count, (uintptr_t)value);
1530
1531 if (context)
1532 {
1533 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1534 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1535 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1536 bool isCallValid =
1537 (context->skipValidation() ||
1538 ValidateProgramUniform4uiv(context, angle::EntryPoint::GLProgramUniform4uiv,
1539 programPacked, locationPacked, count, value));
1540 if (isCallValid)
1541 {
1542 context->programUniform4uiv(programPacked, locationPacked, count, value);
1543 }
1544 ANGLE_CAPTURE(ProgramUniform4uiv, isCallValid, context, programPacked, locationPacked,
1545 count, value);
1546 }
1547 else
1548 {
1549 GenerateContextLostErrorOnCurrentGlobalContext();
1550 }
1551 }
1552
GL_ProgramUniformMatrix2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1553 void GL_APIENTRY GL_ProgramUniformMatrix2fv(GLuint program,
1554 GLint location,
1555 GLsizei count,
1556 GLboolean transpose,
1557 const GLfloat *value)
1558 {
1559 Context *context = GetValidGlobalContext();
1560 EVENT(context, GLProgramUniformMatrix2fv,
1561 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
1562 "0x%016" PRIxPTR "",
1563 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1564
1565 if (context)
1566 {
1567 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1568 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1569 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1570 bool isCallValid = (context->skipValidation() ||
1571 ValidateProgramUniformMatrix2fv(
1572 context, angle::EntryPoint::GLProgramUniformMatrix2fv,
1573 programPacked, locationPacked, count, transpose, value));
1574 if (isCallValid)
1575 {
1576 context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose,
1577 value);
1578 }
1579 ANGLE_CAPTURE(ProgramUniformMatrix2fv, isCallValid, context, programPacked, locationPacked,
1580 count, transpose, value);
1581 }
1582 else
1583 {
1584 GenerateContextLostErrorOnCurrentGlobalContext();
1585 }
1586 }
1587
GL_ProgramUniformMatrix2x3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1588 void GL_APIENTRY GL_ProgramUniformMatrix2x3fv(GLuint program,
1589 GLint location,
1590 GLsizei count,
1591 GLboolean transpose,
1592 const GLfloat *value)
1593 {
1594 Context *context = GetValidGlobalContext();
1595 EVENT(context, GLProgramUniformMatrix2x3fv,
1596 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
1597 "0x%016" PRIxPTR "",
1598 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1599
1600 if (context)
1601 {
1602 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1603 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1604 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1605 bool isCallValid = (context->skipValidation() ||
1606 ValidateProgramUniformMatrix2x3fv(
1607 context, angle::EntryPoint::GLProgramUniformMatrix2x3fv,
1608 programPacked, locationPacked, count, transpose, value));
1609 if (isCallValid)
1610 {
1611 context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose,
1612 value);
1613 }
1614 ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, isCallValid, context, programPacked,
1615 locationPacked, count, transpose, value);
1616 }
1617 else
1618 {
1619 GenerateContextLostErrorOnCurrentGlobalContext();
1620 }
1621 }
1622
GL_ProgramUniformMatrix2x4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1623 void GL_APIENTRY GL_ProgramUniformMatrix2x4fv(GLuint program,
1624 GLint location,
1625 GLsizei count,
1626 GLboolean transpose,
1627 const GLfloat *value)
1628 {
1629 Context *context = GetValidGlobalContext();
1630 EVENT(context, GLProgramUniformMatrix2x4fv,
1631 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
1632 "0x%016" PRIxPTR "",
1633 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1634
1635 if (context)
1636 {
1637 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1638 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1639 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1640 bool isCallValid = (context->skipValidation() ||
1641 ValidateProgramUniformMatrix2x4fv(
1642 context, angle::EntryPoint::GLProgramUniformMatrix2x4fv,
1643 programPacked, locationPacked, count, transpose, value));
1644 if (isCallValid)
1645 {
1646 context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose,
1647 value);
1648 }
1649 ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, isCallValid, context, programPacked,
1650 locationPacked, count, transpose, value);
1651 }
1652 else
1653 {
1654 GenerateContextLostErrorOnCurrentGlobalContext();
1655 }
1656 }
1657
GL_ProgramUniformMatrix3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1658 void GL_APIENTRY GL_ProgramUniformMatrix3fv(GLuint program,
1659 GLint location,
1660 GLsizei count,
1661 GLboolean transpose,
1662 const GLfloat *value)
1663 {
1664 Context *context = GetValidGlobalContext();
1665 EVENT(context, GLProgramUniformMatrix3fv,
1666 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
1667 "0x%016" PRIxPTR "",
1668 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1669
1670 if (context)
1671 {
1672 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1673 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1674 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1675 bool isCallValid = (context->skipValidation() ||
1676 ValidateProgramUniformMatrix3fv(
1677 context, angle::EntryPoint::GLProgramUniformMatrix3fv,
1678 programPacked, locationPacked, count, transpose, value));
1679 if (isCallValid)
1680 {
1681 context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose,
1682 value);
1683 }
1684 ANGLE_CAPTURE(ProgramUniformMatrix3fv, isCallValid, context, programPacked, locationPacked,
1685 count, transpose, value);
1686 }
1687 else
1688 {
1689 GenerateContextLostErrorOnCurrentGlobalContext();
1690 }
1691 }
1692
GL_ProgramUniformMatrix3x2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1693 void GL_APIENTRY GL_ProgramUniformMatrix3x2fv(GLuint program,
1694 GLint location,
1695 GLsizei count,
1696 GLboolean transpose,
1697 const GLfloat *value)
1698 {
1699 Context *context = GetValidGlobalContext();
1700 EVENT(context, GLProgramUniformMatrix3x2fv,
1701 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
1702 "0x%016" PRIxPTR "",
1703 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1704
1705 if (context)
1706 {
1707 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1708 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1709 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1710 bool isCallValid = (context->skipValidation() ||
1711 ValidateProgramUniformMatrix3x2fv(
1712 context, angle::EntryPoint::GLProgramUniformMatrix3x2fv,
1713 programPacked, locationPacked, count, transpose, value));
1714 if (isCallValid)
1715 {
1716 context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose,
1717 value);
1718 }
1719 ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, isCallValid, context, programPacked,
1720 locationPacked, count, transpose, value);
1721 }
1722 else
1723 {
1724 GenerateContextLostErrorOnCurrentGlobalContext();
1725 }
1726 }
1727
GL_ProgramUniformMatrix3x4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1728 void GL_APIENTRY GL_ProgramUniformMatrix3x4fv(GLuint program,
1729 GLint location,
1730 GLsizei count,
1731 GLboolean transpose,
1732 const GLfloat *value)
1733 {
1734 Context *context = GetValidGlobalContext();
1735 EVENT(context, GLProgramUniformMatrix3x4fv,
1736 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
1737 "0x%016" PRIxPTR "",
1738 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1739
1740 if (context)
1741 {
1742 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1743 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1744 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1745 bool isCallValid = (context->skipValidation() ||
1746 ValidateProgramUniformMatrix3x4fv(
1747 context, angle::EntryPoint::GLProgramUniformMatrix3x4fv,
1748 programPacked, locationPacked, count, transpose, value));
1749 if (isCallValid)
1750 {
1751 context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose,
1752 value);
1753 }
1754 ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, isCallValid, context, programPacked,
1755 locationPacked, count, transpose, value);
1756 }
1757 else
1758 {
1759 GenerateContextLostErrorOnCurrentGlobalContext();
1760 }
1761 }
1762
GL_ProgramUniformMatrix4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1763 void GL_APIENTRY GL_ProgramUniformMatrix4fv(GLuint program,
1764 GLint location,
1765 GLsizei count,
1766 GLboolean transpose,
1767 const GLfloat *value)
1768 {
1769 Context *context = GetValidGlobalContext();
1770 EVENT(context, GLProgramUniformMatrix4fv,
1771 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
1772 "0x%016" PRIxPTR "",
1773 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1774
1775 if (context)
1776 {
1777 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1778 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1779 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1780 bool isCallValid = (context->skipValidation() ||
1781 ValidateProgramUniformMatrix4fv(
1782 context, angle::EntryPoint::GLProgramUniformMatrix4fv,
1783 programPacked, locationPacked, count, transpose, value));
1784 if (isCallValid)
1785 {
1786 context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose,
1787 value);
1788 }
1789 ANGLE_CAPTURE(ProgramUniformMatrix4fv, isCallValid, context, programPacked, locationPacked,
1790 count, transpose, value);
1791 }
1792 else
1793 {
1794 GenerateContextLostErrorOnCurrentGlobalContext();
1795 }
1796 }
1797
GL_ProgramUniformMatrix4x2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1798 void GL_APIENTRY GL_ProgramUniformMatrix4x2fv(GLuint program,
1799 GLint location,
1800 GLsizei count,
1801 GLboolean transpose,
1802 const GLfloat *value)
1803 {
1804 Context *context = GetValidGlobalContext();
1805 EVENT(context, GLProgramUniformMatrix4x2fv,
1806 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
1807 "0x%016" PRIxPTR "",
1808 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1809
1810 if (context)
1811 {
1812 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1813 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1814 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1815 bool isCallValid = (context->skipValidation() ||
1816 ValidateProgramUniformMatrix4x2fv(
1817 context, angle::EntryPoint::GLProgramUniformMatrix4x2fv,
1818 programPacked, locationPacked, count, transpose, value));
1819 if (isCallValid)
1820 {
1821 context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose,
1822 value);
1823 }
1824 ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, isCallValid, context, programPacked,
1825 locationPacked, count, transpose, value);
1826 }
1827 else
1828 {
1829 GenerateContextLostErrorOnCurrentGlobalContext();
1830 }
1831 }
1832
GL_ProgramUniformMatrix4x3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1833 void GL_APIENTRY GL_ProgramUniformMatrix4x3fv(GLuint program,
1834 GLint location,
1835 GLsizei count,
1836 GLboolean transpose,
1837 const GLfloat *value)
1838 {
1839 Context *context = GetValidGlobalContext();
1840 EVENT(context, GLProgramUniformMatrix4x3fv,
1841 "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = "
1842 "0x%016" PRIxPTR "",
1843 CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value);
1844
1845 if (context)
1846 {
1847 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1848 UniformLocation locationPacked = PackParam<UniformLocation>(location);
1849 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1850 bool isCallValid = (context->skipValidation() ||
1851 ValidateProgramUniformMatrix4x3fv(
1852 context, angle::EntryPoint::GLProgramUniformMatrix4x3fv,
1853 programPacked, locationPacked, count, transpose, value));
1854 if (isCallValid)
1855 {
1856 context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose,
1857 value);
1858 }
1859 ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, isCallValid, context, programPacked,
1860 locationPacked, count, transpose, value);
1861 }
1862 else
1863 {
1864 GenerateContextLostErrorOnCurrentGlobalContext();
1865 }
1866 }
1867
GL_SampleMaski(GLuint maskNumber,GLbitfield mask)1868 void GL_APIENTRY GL_SampleMaski(GLuint maskNumber, GLbitfield mask)
1869 {
1870 Context *context = GetValidGlobalContext();
1871 EVENT(context, GLSampleMaski, "context = %d, maskNumber = %u, mask = %s", CID(context),
1872 maskNumber, GLbitfieldToString(GLenumGroup::DefaultGroup, mask).c_str());
1873
1874 if (context)
1875 {
1876 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1877 bool isCallValid =
1878 (context->skipValidation() ||
1879 ValidateSampleMaski(context, angle::EntryPoint::GLSampleMaski, maskNumber, mask));
1880 if (isCallValid)
1881 {
1882 context->sampleMaski(maskNumber, mask);
1883 }
1884 ANGLE_CAPTURE(SampleMaski, isCallValid, context, maskNumber, mask);
1885 }
1886 else
1887 {
1888 GenerateContextLostErrorOnCurrentGlobalContext();
1889 }
1890 }
1891
GL_TexStorage2DMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)1892 void GL_APIENTRY GL_TexStorage2DMultisample(GLenum target,
1893 GLsizei samples,
1894 GLenum internalformat,
1895 GLsizei width,
1896 GLsizei height,
1897 GLboolean fixedsamplelocations)
1898 {
1899 Context *context = GetValidGlobalContext();
1900 EVENT(context, GLTexStorage2DMultisample,
1901 "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, "
1902 "fixedsamplelocations = %s",
1903 CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples,
1904 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height,
1905 GLbooleanToString(fixedsamplelocations));
1906
1907 if (context)
1908 {
1909 TextureType targetPacked = PackParam<TextureType>(target);
1910 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1911 bool isCallValid = (context->skipValidation() ||
1912 ValidateTexStorage2DMultisample(
1913 context, angle::EntryPoint::GLTexStorage2DMultisample, targetPacked,
1914 samples, internalformat, width, height, fixedsamplelocations));
1915 if (isCallValid)
1916 {
1917 context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height,
1918 fixedsamplelocations);
1919 }
1920 ANGLE_CAPTURE(TexStorage2DMultisample, isCallValid, context, targetPacked, samples,
1921 internalformat, width, height, fixedsamplelocations);
1922 }
1923 else
1924 {
1925 GenerateContextLostErrorOnCurrentGlobalContext();
1926 }
1927 }
1928
GL_UseProgramStages(GLuint pipeline,GLbitfield stages,GLuint program)1929 void GL_APIENTRY GL_UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
1930 {
1931 Context *context = GetValidGlobalContext();
1932 EVENT(context, GLUseProgramStages, "context = %d, pipeline = %u, stages = %s, program = %u",
1933 CID(context), pipeline,
1934 GLbitfieldToString(GLenumGroup::UseProgramStageMask, stages).c_str(), program);
1935
1936 if (context)
1937 {
1938 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
1939 ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
1940 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1941 bool isCallValid = (context->skipValidation() ||
1942 ValidateUseProgramStages(context, angle::EntryPoint::GLUseProgramStages,
1943 pipelinePacked, stages, programPacked));
1944 if (isCallValid)
1945 {
1946 context->useProgramStages(pipelinePacked, stages, programPacked);
1947 }
1948 ANGLE_CAPTURE(UseProgramStages, isCallValid, context, pipelinePacked, stages,
1949 programPacked);
1950 }
1951 else
1952 {
1953 GenerateContextLostErrorOnCurrentGlobalContext();
1954 }
1955 }
1956
GL_ValidateProgramPipeline(GLuint pipeline)1957 void GL_APIENTRY GL_ValidateProgramPipeline(GLuint pipeline)
1958 {
1959 Context *context = GetValidGlobalContext();
1960 EVENT(context, GLValidateProgramPipeline, "context = %d, pipeline = %u", CID(context),
1961 pipeline);
1962
1963 if (context)
1964 {
1965 ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline);
1966 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1967 bool isCallValid =
1968 (context->skipValidation() ||
1969 ValidateValidateProgramPipeline(context, angle::EntryPoint::GLValidateProgramPipeline,
1970 pipelinePacked));
1971 if (isCallValid)
1972 {
1973 context->validateProgramPipeline(pipelinePacked);
1974 }
1975 ANGLE_CAPTURE(ValidateProgramPipeline, isCallValid, context, pipelinePacked);
1976 }
1977 else
1978 {
1979 GenerateContextLostErrorOnCurrentGlobalContext();
1980 }
1981 }
1982
GL_VertexAttribBinding(GLuint attribindex,GLuint bindingindex)1983 void GL_APIENTRY GL_VertexAttribBinding(GLuint attribindex, GLuint bindingindex)
1984 {
1985 Context *context = GetValidGlobalContext();
1986 EVENT(context, GLVertexAttribBinding, "context = %d, attribindex = %u, bindingindex = %u",
1987 CID(context), attribindex, bindingindex);
1988
1989 if (context)
1990 {
1991 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
1992 bool isCallValid =
1993 (context->skipValidation() ||
1994 ValidateVertexAttribBinding(context, angle::EntryPoint::GLVertexAttribBinding,
1995 attribindex, bindingindex));
1996 if (isCallValid)
1997 {
1998 context->vertexAttribBinding(attribindex, bindingindex);
1999 }
2000 ANGLE_CAPTURE(VertexAttribBinding, isCallValid, context, attribindex, bindingindex);
2001 }
2002 else
2003 {
2004 GenerateContextLostErrorOnCurrentGlobalContext();
2005 }
2006 }
2007
GL_VertexAttribFormat(GLuint attribindex,GLint size,GLenum type,GLboolean normalized,GLuint relativeoffset)2008 void GL_APIENTRY GL_VertexAttribFormat(GLuint attribindex,
2009 GLint size,
2010 GLenum type,
2011 GLboolean normalized,
2012 GLuint relativeoffset)
2013 {
2014 Context *context = GetValidGlobalContext();
2015 EVENT(context, GLVertexAttribFormat,
2016 "context = %d, attribindex = %u, size = %d, type = %s, normalized = %s, relativeoffset = "
2017 "%u",
2018 CID(context), attribindex, size, GLenumToString(GLenumGroup::DefaultGroup, type),
2019 GLbooleanToString(normalized), relativeoffset);
2020
2021 if (context)
2022 {
2023 VertexAttribType typePacked = PackParam<VertexAttribType>(type);
2024 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2025 bool isCallValid =
2026 (context->skipValidation() ||
2027 ValidateVertexAttribFormat(context, angle::EntryPoint::GLVertexAttribFormat,
2028 attribindex, size, typePacked, normalized, relativeoffset));
2029 if (isCallValid)
2030 {
2031 context->vertexAttribFormat(attribindex, size, typePacked, normalized, relativeoffset);
2032 }
2033 ANGLE_CAPTURE(VertexAttribFormat, isCallValid, context, attribindex, size, typePacked,
2034 normalized, relativeoffset);
2035 }
2036 else
2037 {
2038 GenerateContextLostErrorOnCurrentGlobalContext();
2039 }
2040 }
2041
GL_VertexAttribIFormat(GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset)2042 void GL_APIENTRY GL_VertexAttribIFormat(GLuint attribindex,
2043 GLint size,
2044 GLenum type,
2045 GLuint relativeoffset)
2046 {
2047 Context *context = GetValidGlobalContext();
2048 EVENT(context, GLVertexAttribIFormat,
2049 "context = %d, attribindex = %u, size = %d, type = %s, relativeoffset = %u", CID(context),
2050 attribindex, size, GLenumToString(GLenumGroup::DefaultGroup, type), relativeoffset);
2051
2052 if (context)
2053 {
2054 VertexAttribType typePacked = PackParam<VertexAttribType>(type);
2055 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2056 bool isCallValid =
2057 (context->skipValidation() ||
2058 ValidateVertexAttribIFormat(context, angle::EntryPoint::GLVertexAttribIFormat,
2059 attribindex, size, typePacked, relativeoffset));
2060 if (isCallValid)
2061 {
2062 context->vertexAttribIFormat(attribindex, size, typePacked, relativeoffset);
2063 }
2064 ANGLE_CAPTURE(VertexAttribIFormat, isCallValid, context, attribindex, size, typePacked,
2065 relativeoffset);
2066 }
2067 else
2068 {
2069 GenerateContextLostErrorOnCurrentGlobalContext();
2070 }
2071 }
2072
GL_VertexBindingDivisor(GLuint bindingindex,GLuint divisor)2073 void GL_APIENTRY GL_VertexBindingDivisor(GLuint bindingindex, GLuint divisor)
2074 {
2075 Context *context = GetValidGlobalContext();
2076 EVENT(context, GLVertexBindingDivisor, "context = %d, bindingindex = %u, divisor = %u",
2077 CID(context), bindingindex, divisor);
2078
2079 if (context)
2080 {
2081 std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context);
2082 bool isCallValid =
2083 (context->skipValidation() ||
2084 ValidateVertexBindingDivisor(context, angle::EntryPoint::GLVertexBindingDivisor,
2085 bindingindex, divisor));
2086 if (isCallValid)
2087 {
2088 context->vertexBindingDivisor(bindingindex, divisor);
2089 }
2090 ANGLE_CAPTURE(VertexBindingDivisor, isCallValid, context, bindingindex, divisor);
2091 }
2092 else
2093 {
2094 GenerateContextLostErrorOnCurrentGlobalContext();
2095 }
2096 }
2097
2098 } // extern "C"
2099