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