1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml.
3 //
4 // Copyright 2019 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // entry_points_gl_1_3_autogen.cpp:
9 // Defines the GL 1.3 entry points.
10
11 #include "libGL/entry_points_gl_1_3_autogen.h"
12
13 #include "libANGLE/Context.h"
14 #include "libANGLE/Context.inl.h"
15 #include "libANGLE/entry_points_utils.h"
16 #include "libANGLE/gl_enum_utils_autogen.h"
17 #include "libANGLE/validationEGL.h"
18 #include "libANGLE/validationES.h"
19 #include "libANGLE/validationES1.h"
20 #include "libANGLE/validationES2.h"
21 #include "libANGLE/validationES3.h"
22 #include "libANGLE/validationES31.h"
23 #include "libANGLE/validationESEXT.h"
24 #include "libANGLE/validationGL13_autogen.h"
25 #include "libGLESv2/global_state.h"
26
27 namespace gl
28 {
ActiveTexture(GLenum texture)29 void GL_APIENTRY ActiveTexture(GLenum texture)
30 {
31 EVENT("(GLenum texture = %s)", GLenumToString(GLenumGroup::TextureUnit, texture));
32
33 Context *context = GetValidGlobalContext();
34 if (context)
35 {
36 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
37 bool isCallValid = (context->skipValidation() || ValidateActiveTexture(context, texture));
38 if (isCallValid)
39 {
40 context->activeTexture(texture);
41 }
42 ANGLE_CAPTURE(ActiveTexture, isCallValid, context, texture);
43 }
44 }
45
ClientActiveTexture(GLenum texture)46 void GL_APIENTRY ClientActiveTexture(GLenum texture)
47 {
48 EVENT("(GLenum texture = %s)", GLenumToString(GLenumGroup::TextureUnit, texture));
49
50 Context *context = GetValidGlobalContext();
51 if (context)
52 {
53 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
54 bool isCallValid =
55 (context->skipValidation() || ValidateClientActiveTexture(context, texture));
56 if (isCallValid)
57 {
58 context->clientActiveTexture(texture);
59 }
60 ANGLE_CAPTURE(ClientActiveTexture, isCallValid, context, texture);
61 }
62 }
63
CompressedTexImage1D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const void * data)64 void GL_APIENTRY CompressedTexImage1D(GLenum target,
65 GLint level,
66 GLenum internalformat,
67 GLsizei width,
68 GLint border,
69 GLsizei imageSize,
70 const void *data)
71 {
72 EVENT(
73 "(GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei width = %d, "
74 "GLint border = %d, GLsizei imageSize = %d, const void *data = 0x%016" PRIxPTR ")",
75 GLenumToString(GLenumGroup::TextureTarget, target), level,
76 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, border, imageSize,
77 (uintptr_t)data);
78
79 Context *context = GetValidGlobalContext();
80 if (context)
81 {
82 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
83 bool isCallValid = (context->skipValidation() ||
84 ValidateCompressedTexImage1D(context, target, level, internalformat,
85 width, border, imageSize, data));
86 if (isCallValid)
87 {
88 context->compressedTexImage1D(target, level, internalformat, width, border, imageSize,
89 data);
90 }
91 ANGLE_CAPTURE(CompressedTexImage1D, isCallValid, context, target, level, internalformat,
92 width, border, imageSize, data);
93 }
94 }
95
CompressedTexImage2D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const void * data)96 void GL_APIENTRY CompressedTexImage2D(GLenum target,
97 GLint level,
98 GLenum internalformat,
99 GLsizei width,
100 GLsizei height,
101 GLint border,
102 GLsizei imageSize,
103 const void *data)
104 {
105 EVENT(
106 "(GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei width = %d, "
107 "GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, const void *data = "
108 "0x%016" PRIxPTR ")",
109 GLenumToString(GLenumGroup::TextureTarget, target), level,
110 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, border,
111 imageSize, (uintptr_t)data);
112
113 Context *context = GetValidGlobalContext();
114 if (context)
115 {
116 TextureTarget targetPacked = FromGL<TextureTarget>(target);
117 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
118 bool isCallValid =
119 (context->skipValidation() ||
120 ValidateCompressedTexImage2D(context, targetPacked, level, internalformat, width,
121 height, border, imageSize, data));
122 if (isCallValid)
123 {
124 context->compressedTexImage2D(targetPacked, level, internalformat, width, height,
125 border, imageSize, data);
126 }
127 ANGLE_CAPTURE(CompressedTexImage2D, isCallValid, context, targetPacked, level,
128 internalformat, width, height, border, imageSize, data);
129 }
130 }
131
CompressedTexImage3D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const void * data)132 void GL_APIENTRY CompressedTexImage3D(GLenum target,
133 GLint level,
134 GLenum internalformat,
135 GLsizei width,
136 GLsizei height,
137 GLsizei depth,
138 GLint border,
139 GLsizei imageSize,
140 const void *data)
141 {
142 EVENT(
143 "(GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei width = %d, "
144 "GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei imageSize = %d, const "
145 "void *data = 0x%016" PRIxPTR ")",
146 GLenumToString(GLenumGroup::TextureTarget, target), level,
147 GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border,
148 imageSize, (uintptr_t)data);
149
150 Context *context = GetValidGlobalContext();
151 if (context)
152 {
153 TextureTarget targetPacked = FromGL<TextureTarget>(target);
154 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
155 bool isCallValid =
156 (context->skipValidation() ||
157 ValidateCompressedTexImage3D(context, targetPacked, level, internalformat, width,
158 height, depth, border, imageSize, data));
159 if (isCallValid)
160 {
161 context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth,
162 border, imageSize, data);
163 }
164 ANGLE_CAPTURE(CompressedTexImage3D, isCallValid, context, targetPacked, level,
165 internalformat, width, height, depth, border, imageSize, data);
166 }
167 }
168
CompressedTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const void * data)169 void GL_APIENTRY CompressedTexSubImage1D(GLenum target,
170 GLint level,
171 GLint xoffset,
172 GLsizei width,
173 GLenum format,
174 GLsizei imageSize,
175 const void *data)
176 {
177 EVENT(
178 "(GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLsizei width = %d, GLenum "
179 "format = %s, GLsizei imageSize = %d, const void *data = 0x%016" PRIxPTR ")",
180 GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, width,
181 GLenumToString(GLenumGroup::PixelFormat, format), imageSize, (uintptr_t)data);
182
183 Context *context = GetValidGlobalContext();
184 if (context)
185 {
186 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
187 bool isCallValid = (context->skipValidation() ||
188 ValidateCompressedTexSubImage1D(context, target, level, xoffset, width,
189 format, imageSize, data));
190 if (isCallValid)
191 {
192 context->compressedTexSubImage1D(target, level, xoffset, width, format, imageSize,
193 data);
194 }
195 ANGLE_CAPTURE(CompressedTexSubImage1D, isCallValid, context, target, level, xoffset, width,
196 format, imageSize, data);
197 }
198 }
199
CompressedTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const void * data)200 void GL_APIENTRY CompressedTexSubImage2D(GLenum target,
201 GLint level,
202 GLint xoffset,
203 GLint yoffset,
204 GLsizei width,
205 GLsizei height,
206 GLenum format,
207 GLsizei imageSize,
208 const void *data)
209 {
210 EVENT(
211 "(GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLsizei "
212 "width = %d, GLsizei height = %d, GLenum format = %s, GLsizei imageSize = %d, const void "
213 "*data = 0x%016" PRIxPTR ")",
214 GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset, width, height,
215 GLenumToString(GLenumGroup::PixelFormat, format), imageSize, (uintptr_t)data);
216
217 Context *context = GetValidGlobalContext();
218 if (context)
219 {
220 TextureTarget targetPacked = FromGL<TextureTarget>(target);
221 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
222 bool isCallValid =
223 (context->skipValidation() ||
224 ValidateCompressedTexSubImage2D(context, targetPacked, level, xoffset, yoffset, width,
225 height, format, imageSize, data));
226 if (isCallValid)
227 {
228 context->compressedTexSubImage2D(targetPacked, level, xoffset, yoffset, width, height,
229 format, imageSize, data);
230 }
231 ANGLE_CAPTURE(CompressedTexSubImage2D, isCallValid, context, targetPacked, level, xoffset,
232 yoffset, width, height, format, imageSize, data);
233 }
234 }
235
CompressedTexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const void * data)236 void GL_APIENTRY CompressedTexSubImage3D(GLenum target,
237 GLint level,
238 GLint xoffset,
239 GLint yoffset,
240 GLint zoffset,
241 GLsizei width,
242 GLsizei height,
243 GLsizei depth,
244 GLenum format,
245 GLsizei imageSize,
246 const void *data)
247 {
248 EVENT(
249 "(GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
250 "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
251 "= %s, GLsizei imageSize = %d, const void *data = 0x%016" PRIxPTR ")",
252 GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset, zoffset, width,
253 height, depth, GLenumToString(GLenumGroup::PixelFormat, format), imageSize,
254 (uintptr_t)data);
255
256 Context *context = GetValidGlobalContext();
257 if (context)
258 {
259 TextureTarget targetPacked = FromGL<TextureTarget>(target);
260 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
261 bool isCallValid = (context->skipValidation() ||
262 ValidateCompressedTexSubImage3D(context, targetPacked, level, xoffset,
263 yoffset, zoffset, width, height, depth,
264 format, imageSize, data));
265 if (isCallValid)
266 {
267 context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width,
268 height, depth, format, imageSize, data);
269 }
270 ANGLE_CAPTURE(CompressedTexSubImage3D, isCallValid, context, targetPacked, level, xoffset,
271 yoffset, zoffset, width, height, depth, format, imageSize, data);
272 }
273 }
274
GetCompressedTexImage(GLenum target,GLint level,void * img)275 void GL_APIENTRY GetCompressedTexImage(GLenum target, GLint level, void *img)
276 {
277 EVENT("(GLenum target = %s, GLint level = %d, void *img = 0x%016" PRIxPTR ")",
278 GLenumToString(GLenumGroup::TextureTarget, target), level, (uintptr_t)img);
279
280 Context *context = GetValidGlobalContext();
281 if (context)
282 {
283 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
284 bool isCallValid = (context->skipValidation() ||
285 ValidateGetCompressedTexImage(context, target, level, img));
286 if (isCallValid)
287 {
288 context->getCompressedTexImage(target, level, img);
289 }
290 ANGLE_CAPTURE(GetCompressedTexImage, isCallValid, context, target, level, img);
291 }
292 }
293
LoadTransposeMatrixd(const GLdouble * m)294 void GL_APIENTRY LoadTransposeMatrixd(const GLdouble *m)
295 {
296 EVENT("(const GLdouble *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
297
298 Context *context = GetValidGlobalContext();
299 if (context)
300 {
301 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
302 bool isCallValid = (context->skipValidation() || ValidateLoadTransposeMatrixd(context, m));
303 if (isCallValid)
304 {
305 context->loadTransposeMatrixd(m);
306 }
307 ANGLE_CAPTURE(LoadTransposeMatrixd, isCallValid, context, m);
308 }
309 }
310
LoadTransposeMatrixf(const GLfloat * m)311 void GL_APIENTRY LoadTransposeMatrixf(const GLfloat *m)
312 {
313 EVENT("(const GLfloat *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
314
315 Context *context = GetValidGlobalContext();
316 if (context)
317 {
318 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
319 bool isCallValid = (context->skipValidation() || ValidateLoadTransposeMatrixf(context, m));
320 if (isCallValid)
321 {
322 context->loadTransposeMatrixf(m);
323 }
324 ANGLE_CAPTURE(LoadTransposeMatrixf, isCallValid, context, m);
325 }
326 }
327
MultTransposeMatrixd(const GLdouble * m)328 void GL_APIENTRY MultTransposeMatrixd(const GLdouble *m)
329 {
330 EVENT("(const GLdouble *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
331
332 Context *context = GetValidGlobalContext();
333 if (context)
334 {
335 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
336 bool isCallValid = (context->skipValidation() || ValidateMultTransposeMatrixd(context, m));
337 if (isCallValid)
338 {
339 context->multTransposeMatrixd(m);
340 }
341 ANGLE_CAPTURE(MultTransposeMatrixd, isCallValid, context, m);
342 }
343 }
344
MultTransposeMatrixf(const GLfloat * m)345 void GL_APIENTRY MultTransposeMatrixf(const GLfloat *m)
346 {
347 EVENT("(const GLfloat *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
348
349 Context *context = GetValidGlobalContext();
350 if (context)
351 {
352 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
353 bool isCallValid = (context->skipValidation() || ValidateMultTransposeMatrixf(context, m));
354 if (isCallValid)
355 {
356 context->multTransposeMatrixf(m);
357 }
358 ANGLE_CAPTURE(MultTransposeMatrixf, isCallValid, context, m);
359 }
360 }
361
MultiTexCoord1d(GLenum target,GLdouble s)362 void GL_APIENTRY MultiTexCoord1d(GLenum target, GLdouble s)
363 {
364 EVENT("(GLenum target = %s, GLdouble s = %f)", GLenumToString(GLenumGroup::TextureUnit, target),
365 s);
366
367 Context *context = GetValidGlobalContext();
368 if (context)
369 {
370 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
371 bool isCallValid =
372 (context->skipValidation() || ValidateMultiTexCoord1d(context, target, s));
373 if (isCallValid)
374 {
375 context->multiTexCoord1d(target, s);
376 }
377 ANGLE_CAPTURE(MultiTexCoord1d, isCallValid, context, target, s);
378 }
379 }
380
MultiTexCoord1dv(GLenum target,const GLdouble * v)381 void GL_APIENTRY MultiTexCoord1dv(GLenum target, const GLdouble *v)
382 {
383 EVENT("(GLenum target = %s, const GLdouble *v = 0x%016" PRIxPTR ")",
384 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
385
386 Context *context = GetValidGlobalContext();
387 if (context)
388 {
389 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
390 bool isCallValid =
391 (context->skipValidation() || ValidateMultiTexCoord1dv(context, target, v));
392 if (isCallValid)
393 {
394 context->multiTexCoord1dv(target, v);
395 }
396 ANGLE_CAPTURE(MultiTexCoord1dv, isCallValid, context, target, v);
397 }
398 }
399
MultiTexCoord1f(GLenum target,GLfloat s)400 void GL_APIENTRY MultiTexCoord1f(GLenum target, GLfloat s)
401 {
402 EVENT("(GLenum target = %s, GLfloat s = %f)", GLenumToString(GLenumGroup::TextureUnit, target),
403 s);
404
405 Context *context = GetValidGlobalContext();
406 if (context)
407 {
408 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
409 bool isCallValid =
410 (context->skipValidation() || ValidateMultiTexCoord1f(context, target, s));
411 if (isCallValid)
412 {
413 context->multiTexCoord1f(target, s);
414 }
415 ANGLE_CAPTURE(MultiTexCoord1f, isCallValid, context, target, s);
416 }
417 }
418
MultiTexCoord1fv(GLenum target,const GLfloat * v)419 void GL_APIENTRY MultiTexCoord1fv(GLenum target, const GLfloat *v)
420 {
421 EVENT("(GLenum target = %s, const GLfloat *v = 0x%016" PRIxPTR ")",
422 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
423
424 Context *context = GetValidGlobalContext();
425 if (context)
426 {
427 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
428 bool isCallValid =
429 (context->skipValidation() || ValidateMultiTexCoord1fv(context, target, v));
430 if (isCallValid)
431 {
432 context->multiTexCoord1fv(target, v);
433 }
434 ANGLE_CAPTURE(MultiTexCoord1fv, isCallValid, context, target, v);
435 }
436 }
437
MultiTexCoord1i(GLenum target,GLint s)438 void GL_APIENTRY MultiTexCoord1i(GLenum target, GLint s)
439 {
440 EVENT("(GLenum target = %s, GLint s = %d)", GLenumToString(GLenumGroup::TextureUnit, target),
441 s);
442
443 Context *context = GetValidGlobalContext();
444 if (context)
445 {
446 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
447 bool isCallValid =
448 (context->skipValidation() || ValidateMultiTexCoord1i(context, target, s));
449 if (isCallValid)
450 {
451 context->multiTexCoord1i(target, s);
452 }
453 ANGLE_CAPTURE(MultiTexCoord1i, isCallValid, context, target, s);
454 }
455 }
456
MultiTexCoord1iv(GLenum target,const GLint * v)457 void GL_APIENTRY MultiTexCoord1iv(GLenum target, const GLint *v)
458 {
459 EVENT("(GLenum target = %s, const GLint *v = 0x%016" PRIxPTR ")",
460 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
461
462 Context *context = GetValidGlobalContext();
463 if (context)
464 {
465 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
466 bool isCallValid =
467 (context->skipValidation() || ValidateMultiTexCoord1iv(context, target, v));
468 if (isCallValid)
469 {
470 context->multiTexCoord1iv(target, v);
471 }
472 ANGLE_CAPTURE(MultiTexCoord1iv, isCallValid, context, target, v);
473 }
474 }
475
MultiTexCoord1s(GLenum target,GLshort s)476 void GL_APIENTRY MultiTexCoord1s(GLenum target, GLshort s)
477 {
478 EVENT("(GLenum target = %s, GLshort s = %d)", GLenumToString(GLenumGroup::TextureUnit, target),
479 s);
480
481 Context *context = GetValidGlobalContext();
482 if (context)
483 {
484 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
485 bool isCallValid =
486 (context->skipValidation() || ValidateMultiTexCoord1s(context, target, s));
487 if (isCallValid)
488 {
489 context->multiTexCoord1s(target, s);
490 }
491 ANGLE_CAPTURE(MultiTexCoord1s, isCallValid, context, target, s);
492 }
493 }
494
MultiTexCoord1sv(GLenum target,const GLshort * v)495 void GL_APIENTRY MultiTexCoord1sv(GLenum target, const GLshort *v)
496 {
497 EVENT("(GLenum target = %s, const GLshort *v = 0x%016" PRIxPTR ")",
498 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
499
500 Context *context = GetValidGlobalContext();
501 if (context)
502 {
503 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
504 bool isCallValid =
505 (context->skipValidation() || ValidateMultiTexCoord1sv(context, target, v));
506 if (isCallValid)
507 {
508 context->multiTexCoord1sv(target, v);
509 }
510 ANGLE_CAPTURE(MultiTexCoord1sv, isCallValid, context, target, v);
511 }
512 }
513
MultiTexCoord2d(GLenum target,GLdouble s,GLdouble t)514 void GL_APIENTRY MultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
515 {
516 EVENT("(GLenum target = %s, GLdouble s = %f, GLdouble t = %f)",
517 GLenumToString(GLenumGroup::TextureUnit, target), s, t);
518
519 Context *context = GetValidGlobalContext();
520 if (context)
521 {
522 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
523 bool isCallValid =
524 (context->skipValidation() || ValidateMultiTexCoord2d(context, target, s, t));
525 if (isCallValid)
526 {
527 context->multiTexCoord2d(target, s, t);
528 }
529 ANGLE_CAPTURE(MultiTexCoord2d, isCallValid, context, target, s, t);
530 }
531 }
532
MultiTexCoord2dv(GLenum target,const GLdouble * v)533 void GL_APIENTRY MultiTexCoord2dv(GLenum target, const GLdouble *v)
534 {
535 EVENT("(GLenum target = %s, const GLdouble *v = 0x%016" PRIxPTR ")",
536 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
537
538 Context *context = GetValidGlobalContext();
539 if (context)
540 {
541 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
542 bool isCallValid =
543 (context->skipValidation() || ValidateMultiTexCoord2dv(context, target, v));
544 if (isCallValid)
545 {
546 context->multiTexCoord2dv(target, v);
547 }
548 ANGLE_CAPTURE(MultiTexCoord2dv, isCallValid, context, target, v);
549 }
550 }
551
MultiTexCoord2f(GLenum target,GLfloat s,GLfloat t)552 void GL_APIENTRY MultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
553 {
554 EVENT("(GLenum target = %s, GLfloat s = %f, GLfloat t = %f)",
555 GLenumToString(GLenumGroup::TextureUnit, target), s, t);
556
557 Context *context = GetValidGlobalContext();
558 if (context)
559 {
560 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
561 bool isCallValid =
562 (context->skipValidation() || ValidateMultiTexCoord2f(context, target, s, t));
563 if (isCallValid)
564 {
565 context->multiTexCoord2f(target, s, t);
566 }
567 ANGLE_CAPTURE(MultiTexCoord2f, isCallValid, context, target, s, t);
568 }
569 }
570
MultiTexCoord2fv(GLenum target,const GLfloat * v)571 void GL_APIENTRY MultiTexCoord2fv(GLenum target, const GLfloat *v)
572 {
573 EVENT("(GLenum target = %s, const GLfloat *v = 0x%016" PRIxPTR ")",
574 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
575
576 Context *context = GetValidGlobalContext();
577 if (context)
578 {
579 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
580 bool isCallValid =
581 (context->skipValidation() || ValidateMultiTexCoord2fv(context, target, v));
582 if (isCallValid)
583 {
584 context->multiTexCoord2fv(target, v);
585 }
586 ANGLE_CAPTURE(MultiTexCoord2fv, isCallValid, context, target, v);
587 }
588 }
589
MultiTexCoord2i(GLenum target,GLint s,GLint t)590 void GL_APIENTRY MultiTexCoord2i(GLenum target, GLint s, GLint t)
591 {
592 EVENT("(GLenum target = %s, GLint s = %d, GLint t = %d)",
593 GLenumToString(GLenumGroup::TextureUnit, target), s, t);
594
595 Context *context = GetValidGlobalContext();
596 if (context)
597 {
598 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
599 bool isCallValid =
600 (context->skipValidation() || ValidateMultiTexCoord2i(context, target, s, t));
601 if (isCallValid)
602 {
603 context->multiTexCoord2i(target, s, t);
604 }
605 ANGLE_CAPTURE(MultiTexCoord2i, isCallValid, context, target, s, t);
606 }
607 }
608
MultiTexCoord2iv(GLenum target,const GLint * v)609 void GL_APIENTRY MultiTexCoord2iv(GLenum target, const GLint *v)
610 {
611 EVENT("(GLenum target = %s, const GLint *v = 0x%016" PRIxPTR ")",
612 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
613
614 Context *context = GetValidGlobalContext();
615 if (context)
616 {
617 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
618 bool isCallValid =
619 (context->skipValidation() || ValidateMultiTexCoord2iv(context, target, v));
620 if (isCallValid)
621 {
622 context->multiTexCoord2iv(target, v);
623 }
624 ANGLE_CAPTURE(MultiTexCoord2iv, isCallValid, context, target, v);
625 }
626 }
627
MultiTexCoord2s(GLenum target,GLshort s,GLshort t)628 void GL_APIENTRY MultiTexCoord2s(GLenum target, GLshort s, GLshort t)
629 {
630 EVENT("(GLenum target = %s, GLshort s = %d, GLshort t = %d)",
631 GLenumToString(GLenumGroup::TextureUnit, target), s, t);
632
633 Context *context = GetValidGlobalContext();
634 if (context)
635 {
636 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
637 bool isCallValid =
638 (context->skipValidation() || ValidateMultiTexCoord2s(context, target, s, t));
639 if (isCallValid)
640 {
641 context->multiTexCoord2s(target, s, t);
642 }
643 ANGLE_CAPTURE(MultiTexCoord2s, isCallValid, context, target, s, t);
644 }
645 }
646
MultiTexCoord2sv(GLenum target,const GLshort * v)647 void GL_APIENTRY MultiTexCoord2sv(GLenum target, const GLshort *v)
648 {
649 EVENT("(GLenum target = %s, const GLshort *v = 0x%016" PRIxPTR ")",
650 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
651
652 Context *context = GetValidGlobalContext();
653 if (context)
654 {
655 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
656 bool isCallValid =
657 (context->skipValidation() || ValidateMultiTexCoord2sv(context, target, v));
658 if (isCallValid)
659 {
660 context->multiTexCoord2sv(target, v);
661 }
662 ANGLE_CAPTURE(MultiTexCoord2sv, isCallValid, context, target, v);
663 }
664 }
665
MultiTexCoord3d(GLenum target,GLdouble s,GLdouble t,GLdouble r)666 void GL_APIENTRY MultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
667 {
668 EVENT("(GLenum target = %s, GLdouble s = %f, GLdouble t = %f, GLdouble r = %f)",
669 GLenumToString(GLenumGroup::TextureUnit, target), s, t, r);
670
671 Context *context = GetValidGlobalContext();
672 if (context)
673 {
674 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
675 bool isCallValid =
676 (context->skipValidation() || ValidateMultiTexCoord3d(context, target, s, t, r));
677 if (isCallValid)
678 {
679 context->multiTexCoord3d(target, s, t, r);
680 }
681 ANGLE_CAPTURE(MultiTexCoord3d, isCallValid, context, target, s, t, r);
682 }
683 }
684
MultiTexCoord3dv(GLenum target,const GLdouble * v)685 void GL_APIENTRY MultiTexCoord3dv(GLenum target, const GLdouble *v)
686 {
687 EVENT("(GLenum target = %s, const GLdouble *v = 0x%016" PRIxPTR ")",
688 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
689
690 Context *context = GetValidGlobalContext();
691 if (context)
692 {
693 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
694 bool isCallValid =
695 (context->skipValidation() || ValidateMultiTexCoord3dv(context, target, v));
696 if (isCallValid)
697 {
698 context->multiTexCoord3dv(target, v);
699 }
700 ANGLE_CAPTURE(MultiTexCoord3dv, isCallValid, context, target, v);
701 }
702 }
703
MultiTexCoord3f(GLenum target,GLfloat s,GLfloat t,GLfloat r)704 void GL_APIENTRY MultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
705 {
706 EVENT("(GLenum target = %s, GLfloat s = %f, GLfloat t = %f, GLfloat r = %f)",
707 GLenumToString(GLenumGroup::TextureUnit, target), s, t, r);
708
709 Context *context = GetValidGlobalContext();
710 if (context)
711 {
712 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
713 bool isCallValid =
714 (context->skipValidation() || ValidateMultiTexCoord3f(context, target, s, t, r));
715 if (isCallValid)
716 {
717 context->multiTexCoord3f(target, s, t, r);
718 }
719 ANGLE_CAPTURE(MultiTexCoord3f, isCallValid, context, target, s, t, r);
720 }
721 }
722
MultiTexCoord3fv(GLenum target,const GLfloat * v)723 void GL_APIENTRY MultiTexCoord3fv(GLenum target, const GLfloat *v)
724 {
725 EVENT("(GLenum target = %s, const GLfloat *v = 0x%016" PRIxPTR ")",
726 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
727
728 Context *context = GetValidGlobalContext();
729 if (context)
730 {
731 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
732 bool isCallValid =
733 (context->skipValidation() || ValidateMultiTexCoord3fv(context, target, v));
734 if (isCallValid)
735 {
736 context->multiTexCoord3fv(target, v);
737 }
738 ANGLE_CAPTURE(MultiTexCoord3fv, isCallValid, context, target, v);
739 }
740 }
741
MultiTexCoord3i(GLenum target,GLint s,GLint t,GLint r)742 void GL_APIENTRY MultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
743 {
744 EVENT("(GLenum target = %s, GLint s = %d, GLint t = %d, GLint r = %d)",
745 GLenumToString(GLenumGroup::TextureUnit, target), s, t, r);
746
747 Context *context = GetValidGlobalContext();
748 if (context)
749 {
750 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
751 bool isCallValid =
752 (context->skipValidation() || ValidateMultiTexCoord3i(context, target, s, t, r));
753 if (isCallValid)
754 {
755 context->multiTexCoord3i(target, s, t, r);
756 }
757 ANGLE_CAPTURE(MultiTexCoord3i, isCallValid, context, target, s, t, r);
758 }
759 }
760
MultiTexCoord3iv(GLenum target,const GLint * v)761 void GL_APIENTRY MultiTexCoord3iv(GLenum target, const GLint *v)
762 {
763 EVENT("(GLenum target = %s, const GLint *v = 0x%016" PRIxPTR ")",
764 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
765
766 Context *context = GetValidGlobalContext();
767 if (context)
768 {
769 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
770 bool isCallValid =
771 (context->skipValidation() || ValidateMultiTexCoord3iv(context, target, v));
772 if (isCallValid)
773 {
774 context->multiTexCoord3iv(target, v);
775 }
776 ANGLE_CAPTURE(MultiTexCoord3iv, isCallValid, context, target, v);
777 }
778 }
779
MultiTexCoord3s(GLenum target,GLshort s,GLshort t,GLshort r)780 void GL_APIENTRY MultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
781 {
782 EVENT("(GLenum target = %s, GLshort s = %d, GLshort t = %d, GLshort r = %d)",
783 GLenumToString(GLenumGroup::TextureUnit, target), s, t, r);
784
785 Context *context = GetValidGlobalContext();
786 if (context)
787 {
788 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
789 bool isCallValid =
790 (context->skipValidation() || ValidateMultiTexCoord3s(context, target, s, t, r));
791 if (isCallValid)
792 {
793 context->multiTexCoord3s(target, s, t, r);
794 }
795 ANGLE_CAPTURE(MultiTexCoord3s, isCallValid, context, target, s, t, r);
796 }
797 }
798
MultiTexCoord3sv(GLenum target,const GLshort * v)799 void GL_APIENTRY MultiTexCoord3sv(GLenum target, const GLshort *v)
800 {
801 EVENT("(GLenum target = %s, const GLshort *v = 0x%016" PRIxPTR ")",
802 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
803
804 Context *context = GetValidGlobalContext();
805 if (context)
806 {
807 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
808 bool isCallValid =
809 (context->skipValidation() || ValidateMultiTexCoord3sv(context, target, v));
810 if (isCallValid)
811 {
812 context->multiTexCoord3sv(target, v);
813 }
814 ANGLE_CAPTURE(MultiTexCoord3sv, isCallValid, context, target, v);
815 }
816 }
817
MultiTexCoord4d(GLenum target,GLdouble s,GLdouble t,GLdouble r,GLdouble q)818 void GL_APIENTRY MultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
819 {
820 EVENT(
821 "(GLenum target = %s, GLdouble s = %f, GLdouble t = %f, GLdouble r = %f, GLdouble q = %f)",
822 GLenumToString(GLenumGroup::TextureUnit, target), s, t, r, q);
823
824 Context *context = GetValidGlobalContext();
825 if (context)
826 {
827 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
828 bool isCallValid =
829 (context->skipValidation() || ValidateMultiTexCoord4d(context, target, s, t, r, q));
830 if (isCallValid)
831 {
832 context->multiTexCoord4d(target, s, t, r, q);
833 }
834 ANGLE_CAPTURE(MultiTexCoord4d, isCallValid, context, target, s, t, r, q);
835 }
836 }
837
MultiTexCoord4dv(GLenum target,const GLdouble * v)838 void GL_APIENTRY MultiTexCoord4dv(GLenum target, const GLdouble *v)
839 {
840 EVENT("(GLenum target = %s, const GLdouble *v = 0x%016" PRIxPTR ")",
841 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
842
843 Context *context = GetValidGlobalContext();
844 if (context)
845 {
846 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
847 bool isCallValid =
848 (context->skipValidation() || ValidateMultiTexCoord4dv(context, target, v));
849 if (isCallValid)
850 {
851 context->multiTexCoord4dv(target, v);
852 }
853 ANGLE_CAPTURE(MultiTexCoord4dv, isCallValid, context, target, v);
854 }
855 }
856
MultiTexCoord4f(GLenum target,GLfloat s,GLfloat t,GLfloat r,GLfloat q)857 void GL_APIENTRY MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
858 {
859 EVENT("(GLenum target = %s, GLfloat s = %f, GLfloat t = %f, GLfloat r = %f, GLfloat q = %f)",
860 GLenumToString(GLenumGroup::TextureUnit, target), s, t, r, q);
861
862 Context *context = GetValidGlobalContext();
863 if (context)
864 {
865 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
866 bool isCallValid =
867 (context->skipValidation() || ValidateMultiTexCoord4f(context, target, s, t, r, q));
868 if (isCallValid)
869 {
870 context->multiTexCoord4f(target, s, t, r, q);
871 }
872 ANGLE_CAPTURE(MultiTexCoord4f, isCallValid, context, target, s, t, r, q);
873 }
874 }
875
MultiTexCoord4fv(GLenum target,const GLfloat * v)876 void GL_APIENTRY MultiTexCoord4fv(GLenum target, const GLfloat *v)
877 {
878 EVENT("(GLenum target = %s, const GLfloat *v = 0x%016" PRIxPTR ")",
879 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
880
881 Context *context = GetValidGlobalContext();
882 if (context)
883 {
884 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
885 bool isCallValid =
886 (context->skipValidation() || ValidateMultiTexCoord4fv(context, target, v));
887 if (isCallValid)
888 {
889 context->multiTexCoord4fv(target, v);
890 }
891 ANGLE_CAPTURE(MultiTexCoord4fv, isCallValid, context, target, v);
892 }
893 }
894
MultiTexCoord4i(GLenum target,GLint s,GLint t,GLint r,GLint q)895 void GL_APIENTRY MultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
896 {
897 EVENT("(GLenum target = %s, GLint s = %d, GLint t = %d, GLint r = %d, GLint q = %d)",
898 GLenumToString(GLenumGroup::TextureUnit, target), s, t, r, q);
899
900 Context *context = GetValidGlobalContext();
901 if (context)
902 {
903 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
904 bool isCallValid =
905 (context->skipValidation() || ValidateMultiTexCoord4i(context, target, s, t, r, q));
906 if (isCallValid)
907 {
908 context->multiTexCoord4i(target, s, t, r, q);
909 }
910 ANGLE_CAPTURE(MultiTexCoord4i, isCallValid, context, target, s, t, r, q);
911 }
912 }
913
MultiTexCoord4iv(GLenum target,const GLint * v)914 void GL_APIENTRY MultiTexCoord4iv(GLenum target, const GLint *v)
915 {
916 EVENT("(GLenum target = %s, const GLint *v = 0x%016" PRIxPTR ")",
917 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
918
919 Context *context = GetValidGlobalContext();
920 if (context)
921 {
922 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
923 bool isCallValid =
924 (context->skipValidation() || ValidateMultiTexCoord4iv(context, target, v));
925 if (isCallValid)
926 {
927 context->multiTexCoord4iv(target, v);
928 }
929 ANGLE_CAPTURE(MultiTexCoord4iv, isCallValid, context, target, v);
930 }
931 }
932
MultiTexCoord4s(GLenum target,GLshort s,GLshort t,GLshort r,GLshort q)933 void GL_APIENTRY MultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
934 {
935 EVENT("(GLenum target = %s, GLshort s = %d, GLshort t = %d, GLshort r = %d, GLshort q = %d)",
936 GLenumToString(GLenumGroup::TextureUnit, target), s, t, r, q);
937
938 Context *context = GetValidGlobalContext();
939 if (context)
940 {
941 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
942 bool isCallValid =
943 (context->skipValidation() || ValidateMultiTexCoord4s(context, target, s, t, r, q));
944 if (isCallValid)
945 {
946 context->multiTexCoord4s(target, s, t, r, q);
947 }
948 ANGLE_CAPTURE(MultiTexCoord4s, isCallValid, context, target, s, t, r, q);
949 }
950 }
951
MultiTexCoord4sv(GLenum target,const GLshort * v)952 void GL_APIENTRY MultiTexCoord4sv(GLenum target, const GLshort *v)
953 {
954 EVENT("(GLenum target = %s, const GLshort *v = 0x%016" PRIxPTR ")",
955 GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v);
956
957 Context *context = GetValidGlobalContext();
958 if (context)
959 {
960 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
961 bool isCallValid =
962 (context->skipValidation() || ValidateMultiTexCoord4sv(context, target, v));
963 if (isCallValid)
964 {
965 context->multiTexCoord4sv(target, v);
966 }
967 ANGLE_CAPTURE(MultiTexCoord4sv, isCallValid, context, target, v);
968 }
969 }
970
SampleCoverage(GLfloat value,GLboolean invert)971 void GL_APIENTRY SampleCoverage(GLfloat value, GLboolean invert)
972 {
973 EVENT("(GLfloat value = %f, GLboolean invert = %s)", value, GLbooleanToString(invert));
974
975 Context *context = GetValidGlobalContext();
976 if (context)
977 {
978 std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
979 bool isCallValid =
980 (context->skipValidation() || ValidateSampleCoverage(context, value, invert));
981 if (isCallValid)
982 {
983 context->sampleCoverage(value, invert);
984 }
985 ANGLE_CAPTURE(SampleCoverage, isCallValid, context, value, invert);
986 }
987 }
988 } // namespace gl
989