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_4_autogen.cpp:
9 // Defines the GL 1.4 entry points.
10
11 #include "libGL/entry_points_gl_1_4_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/validationGL14_autogen.h"
26 #include "libGLESv2/global_state.h"
27
28 namespace gl
29 {
BlendColor(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)30 void GL_APIENTRY BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
31 {
32 Context *context = GetValidGlobalContext();
33 EVENT(
34 "glBlendColor",
35 "context = %d, GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f",
36 CID(context), red, green, blue, alpha);
37
38 if (context)
39 {
40 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
41 bool isCallValid =
42 (context->skipValidation() || ValidateBlendColor(context, red, green, blue, alpha));
43 if (isCallValid)
44 {
45 context->blendColor(red, green, blue, alpha);
46 }
47 ANGLE_CAPTURE(BlendColor, isCallValid, context, red, green, blue, alpha);
48 }
49 }
50
BlendEquation(GLenum mode)51 void GL_APIENTRY BlendEquation(GLenum mode)
52 {
53 Context *context = GetValidGlobalContext();
54 EVENT("glBlendEquation", "context = %d, GLenum mode = %s", CID(context),
55 GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
56
57 if (context)
58 {
59 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
60 bool isCallValid = (context->skipValidation() || ValidateBlendEquation(context, mode));
61 if (isCallValid)
62 {
63 context->blendEquation(mode);
64 }
65 ANGLE_CAPTURE(BlendEquation, isCallValid, context, mode);
66 }
67 }
68
BlendFuncSeparate(GLenum sfactorRGB,GLenum dfactorRGB,GLenum sfactorAlpha,GLenum dfactorAlpha)69 void GL_APIENTRY BlendFuncSeparate(GLenum sfactorRGB,
70 GLenum dfactorRGB,
71 GLenum sfactorAlpha,
72 GLenum dfactorAlpha)
73 {
74 Context *context = GetValidGlobalContext();
75 EVENT("glBlendFuncSeparate",
76 "context = %d, GLenum sfactorRGB = %s, GLenum dfactorRGB = %s, GLenum sfactorAlpha = %s, "
77 "GLenum dfactorAlpha = %s",
78 CID(context), GLenumToString(GLenumGroup::BlendingFactor, sfactorRGB),
79 GLenumToString(GLenumGroup::BlendingFactor, dfactorRGB),
80 GLenumToString(GLenumGroup::BlendingFactor, sfactorAlpha),
81 GLenumToString(GLenumGroup::BlendingFactor, dfactorAlpha));
82
83 if (context)
84 {
85 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
86 bool isCallValid =
87 (context->skipValidation() || ValidateBlendFuncSeparate(context, sfactorRGB, dfactorRGB,
88 sfactorAlpha, dfactorAlpha));
89 if (isCallValid)
90 {
91 context->blendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
92 }
93 ANGLE_CAPTURE(BlendFuncSeparate, isCallValid, context, sfactorRGB, dfactorRGB, sfactorAlpha,
94 dfactorAlpha);
95 }
96 }
97
FogCoordPointer(GLenum type,GLsizei stride,const void * pointer)98 void GL_APIENTRY FogCoordPointer(GLenum type, GLsizei stride, const void *pointer)
99 {
100 Context *context = GetValidGlobalContext();
101 EVENT(
102 "glFogCoordPointer",
103 "context = %d, GLenum type = %s, GLsizei stride = %d, const void *pointer = 0x%016" PRIxPTR
104 "",
105 CID(context), GLenumToString(GLenumGroup::FogPointerTypeEXT, type), stride,
106 (uintptr_t)pointer);
107
108 if (context)
109 {
110 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
111 bool isCallValid =
112 (context->skipValidation() || ValidateFogCoordPointer(context, type, stride, pointer));
113 if (isCallValid)
114 {
115 context->fogCoordPointer(type, stride, pointer);
116 }
117 ANGLE_CAPTURE(FogCoordPointer, isCallValid, context, type, stride, pointer);
118 }
119 }
120
FogCoordd(GLdouble coord)121 void GL_APIENTRY FogCoordd(GLdouble coord)
122 {
123 Context *context = GetValidGlobalContext();
124 EVENT("glFogCoordd", "context = %d, GLdouble coord = %f", CID(context), coord);
125
126 if (context)
127 {
128 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
129 bool isCallValid = (context->skipValidation() || ValidateFogCoordd(context, coord));
130 if (isCallValid)
131 {
132 context->fogCoordd(coord);
133 }
134 ANGLE_CAPTURE(FogCoordd, isCallValid, context, coord);
135 }
136 }
137
FogCoorddv(const GLdouble * coord)138 void GL_APIENTRY FogCoorddv(const GLdouble *coord)
139 {
140 Context *context = GetValidGlobalContext();
141 EVENT("glFogCoorddv", "context = %d, const GLdouble *coord = 0x%016" PRIxPTR "", CID(context),
142 (uintptr_t)coord);
143
144 if (context)
145 {
146 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
147 bool isCallValid = (context->skipValidation() || ValidateFogCoorddv(context, coord));
148 if (isCallValid)
149 {
150 context->fogCoorddv(coord);
151 }
152 ANGLE_CAPTURE(FogCoorddv, isCallValid, context, coord);
153 }
154 }
155
FogCoordf(GLfloat coord)156 void GL_APIENTRY FogCoordf(GLfloat coord)
157 {
158 Context *context = GetValidGlobalContext();
159 EVENT("glFogCoordf", "context = %d, GLfloat coord = %f", CID(context), coord);
160
161 if (context)
162 {
163 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
164 bool isCallValid = (context->skipValidation() || ValidateFogCoordf(context, coord));
165 if (isCallValid)
166 {
167 context->fogCoordf(coord);
168 }
169 ANGLE_CAPTURE(FogCoordf, isCallValid, context, coord);
170 }
171 }
172
FogCoordfv(const GLfloat * coord)173 void GL_APIENTRY FogCoordfv(const GLfloat *coord)
174 {
175 Context *context = GetValidGlobalContext();
176 EVENT("glFogCoordfv", "context = %d, const GLfloat *coord = 0x%016" PRIxPTR "", CID(context),
177 (uintptr_t)coord);
178
179 if (context)
180 {
181 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
182 bool isCallValid = (context->skipValidation() || ValidateFogCoordfv(context, coord));
183 if (isCallValid)
184 {
185 context->fogCoordfv(coord);
186 }
187 ANGLE_CAPTURE(FogCoordfv, isCallValid, context, coord);
188 }
189 }
190
MultiDrawArrays(GLenum mode,const GLint * first,const GLsizei * count,GLsizei drawcount)191 void GL_APIENTRY MultiDrawArrays(GLenum mode,
192 const GLint *first,
193 const GLsizei *count,
194 GLsizei drawcount)
195 {
196 Context *context = GetValidGlobalContext();
197 EVENT("glMultiDrawArrays",
198 "context = %d, GLenum mode = %s, const GLint *first = 0x%016" PRIxPTR
199 ", const GLsizei *count = 0x%016" PRIxPTR ", GLsizei drawcount = %d",
200 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)first,
201 (uintptr_t)count, drawcount);
202
203 if (context)
204 {
205 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
206 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
207 bool isCallValid = (context->skipValidation() ||
208 ValidateMultiDrawArrays(context, modePacked, first, count, drawcount));
209 if (isCallValid)
210 {
211 context->multiDrawArrays(modePacked, first, count, drawcount);
212 }
213 ANGLE_CAPTURE(MultiDrawArrays, isCallValid, context, modePacked, first, count, drawcount);
214 }
215 }
216
MultiDrawElements(GLenum mode,const GLsizei * count,GLenum type,const void * const * indices,GLsizei drawcount)217 void GL_APIENTRY MultiDrawElements(GLenum mode,
218 const GLsizei *count,
219 GLenum type,
220 const void *const *indices,
221 GLsizei drawcount)
222 {
223 Context *context = GetValidGlobalContext();
224 EVENT("glMultiDrawElements",
225 "context = %d, GLenum mode = %s, const GLsizei *count = 0x%016" PRIxPTR
226 ", GLenum type = %s, const void *const*indices = 0x%016" PRIxPTR
227 ", GLsizei drawcount = %d",
228 CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)count,
229 GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, drawcount);
230
231 if (context)
232 {
233 PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
234 DrawElementsType typePacked = FromGL<DrawElementsType>(type);
235 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
236 bool isCallValid =
237 (context->skipValidation() ||
238 ValidateMultiDrawElements(context, modePacked, count, typePacked, indices, drawcount));
239 if (isCallValid)
240 {
241 context->multiDrawElements(modePacked, count, typePacked, indices, drawcount);
242 }
243 ANGLE_CAPTURE(MultiDrawElements, isCallValid, context, modePacked, count, typePacked,
244 indices, drawcount);
245 }
246 }
247
PointParameterf(GLenum pname,GLfloat param)248 void GL_APIENTRY PointParameterf(GLenum pname, GLfloat param)
249 {
250 Context *context = GetValidGlobalContext();
251 EVENT("glPointParameterf", "context = %d, GLenum pname = %s, GLfloat param = %f", CID(context),
252 GLenumToString(GLenumGroup::DefaultGroup, pname), param);
253
254 if (context)
255 {
256 PointParameter pnamePacked = FromGL<PointParameter>(pname);
257 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
258 bool isCallValid =
259 (context->skipValidation() || ValidatePointParameterf(context, pnamePacked, param));
260 if (isCallValid)
261 {
262 context->pointParameterf(pnamePacked, param);
263 }
264 ANGLE_CAPTURE(PointParameterf, isCallValid, context, pnamePacked, param);
265 }
266 }
267
PointParameterfv(GLenum pname,const GLfloat * params)268 void GL_APIENTRY PointParameterfv(GLenum pname, const GLfloat *params)
269 {
270 Context *context = GetValidGlobalContext();
271 EVENT("glPointParameterfv",
272 "context = %d, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR "",
273 CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
274
275 if (context)
276 {
277 PointParameter pnamePacked = FromGL<PointParameter>(pname);
278 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
279 bool isCallValid =
280 (context->skipValidation() || ValidatePointParameterfv(context, pnamePacked, params));
281 if (isCallValid)
282 {
283 context->pointParameterfv(pnamePacked, params);
284 }
285 ANGLE_CAPTURE(PointParameterfv, isCallValid, context, pnamePacked, params);
286 }
287 }
288
PointParameteri(GLenum pname,GLint param)289 void GL_APIENTRY PointParameteri(GLenum pname, GLint param)
290 {
291 Context *context = GetValidGlobalContext();
292 EVENT("glPointParameteri", "context = %d, GLenum pname = %s, GLint param = %d", CID(context),
293 GLenumToString(GLenumGroup::DefaultGroup, pname), param);
294
295 if (context)
296 {
297 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
298 bool isCallValid =
299 (context->skipValidation() || ValidatePointParameteri(context, pname, param));
300 if (isCallValid)
301 {
302 context->pointParameteri(pname, param);
303 }
304 ANGLE_CAPTURE(PointParameteri, isCallValid, context, pname, param);
305 }
306 }
307
PointParameteriv(GLenum pname,const GLint * params)308 void GL_APIENTRY PointParameteriv(GLenum pname, const GLint *params)
309 {
310 Context *context = GetValidGlobalContext();
311 EVENT("glPointParameteriv",
312 "context = %d, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR "", CID(context),
313 GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params);
314
315 if (context)
316 {
317 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
318 bool isCallValid =
319 (context->skipValidation() || ValidatePointParameteriv(context, pname, params));
320 if (isCallValid)
321 {
322 context->pointParameteriv(pname, params);
323 }
324 ANGLE_CAPTURE(PointParameteriv, isCallValid, context, pname, params);
325 }
326 }
327
SecondaryColor3b(GLbyte red,GLbyte green,GLbyte blue)328 void GL_APIENTRY SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
329 {
330 Context *context = GetValidGlobalContext();
331 EVENT("glSecondaryColor3b",
332 "context = %d, GLbyte red = %d, GLbyte green = %d, GLbyte blue = %d", CID(context), red,
333 green, blue);
334
335 if (context)
336 {
337 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
338 bool isCallValid =
339 (context->skipValidation() || ValidateSecondaryColor3b(context, red, green, blue));
340 if (isCallValid)
341 {
342 context->secondaryColor3b(red, green, blue);
343 }
344 ANGLE_CAPTURE(SecondaryColor3b, isCallValid, context, red, green, blue);
345 }
346 }
347
SecondaryColor3bv(const GLbyte * v)348 void GL_APIENTRY SecondaryColor3bv(const GLbyte *v)
349 {
350 Context *context = GetValidGlobalContext();
351 EVENT("glSecondaryColor3bv", "context = %d, const GLbyte *v = 0x%016" PRIxPTR "", CID(context),
352 (uintptr_t)v);
353
354 if (context)
355 {
356 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
357 bool isCallValid = (context->skipValidation() || ValidateSecondaryColor3bv(context, v));
358 if (isCallValid)
359 {
360 context->secondaryColor3bv(v);
361 }
362 ANGLE_CAPTURE(SecondaryColor3bv, isCallValid, context, v);
363 }
364 }
365
SecondaryColor3d(GLdouble red,GLdouble green,GLdouble blue)366 void GL_APIENTRY SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
367 {
368 Context *context = GetValidGlobalContext();
369 EVENT("glSecondaryColor3d",
370 "context = %d, GLdouble red = %f, GLdouble green = %f, GLdouble blue = %f", CID(context),
371 red, green, blue);
372
373 if (context)
374 {
375 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
376 bool isCallValid =
377 (context->skipValidation() || ValidateSecondaryColor3d(context, red, green, blue));
378 if (isCallValid)
379 {
380 context->secondaryColor3d(red, green, blue);
381 }
382 ANGLE_CAPTURE(SecondaryColor3d, isCallValid, context, red, green, blue);
383 }
384 }
385
SecondaryColor3dv(const GLdouble * v)386 void GL_APIENTRY SecondaryColor3dv(const GLdouble *v)
387 {
388 Context *context = GetValidGlobalContext();
389 EVENT("glSecondaryColor3dv", "context = %d, const GLdouble *v = 0x%016" PRIxPTR "",
390 CID(context), (uintptr_t)v);
391
392 if (context)
393 {
394 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
395 bool isCallValid = (context->skipValidation() || ValidateSecondaryColor3dv(context, v));
396 if (isCallValid)
397 {
398 context->secondaryColor3dv(v);
399 }
400 ANGLE_CAPTURE(SecondaryColor3dv, isCallValid, context, v);
401 }
402 }
403
SecondaryColor3f(GLfloat red,GLfloat green,GLfloat blue)404 void GL_APIENTRY SecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
405 {
406 Context *context = GetValidGlobalContext();
407 EVENT("glSecondaryColor3f",
408 "context = %d, GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f", CID(context),
409 red, green, blue);
410
411 if (context)
412 {
413 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
414 bool isCallValid =
415 (context->skipValidation() || ValidateSecondaryColor3f(context, red, green, blue));
416 if (isCallValid)
417 {
418 context->secondaryColor3f(red, green, blue);
419 }
420 ANGLE_CAPTURE(SecondaryColor3f, isCallValid, context, red, green, blue);
421 }
422 }
423
SecondaryColor3fv(const GLfloat * v)424 void GL_APIENTRY SecondaryColor3fv(const GLfloat *v)
425 {
426 Context *context = GetValidGlobalContext();
427 EVENT("glSecondaryColor3fv", "context = %d, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
428 (uintptr_t)v);
429
430 if (context)
431 {
432 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
433 bool isCallValid = (context->skipValidation() || ValidateSecondaryColor3fv(context, v));
434 if (isCallValid)
435 {
436 context->secondaryColor3fv(v);
437 }
438 ANGLE_CAPTURE(SecondaryColor3fv, isCallValid, context, v);
439 }
440 }
441
SecondaryColor3i(GLint red,GLint green,GLint blue)442 void GL_APIENTRY SecondaryColor3i(GLint red, GLint green, GLint blue)
443 {
444 Context *context = GetValidGlobalContext();
445 EVENT("glSecondaryColor3i", "context = %d, GLint red = %d, GLint green = %d, GLint blue = %d",
446 CID(context), red, green, blue);
447
448 if (context)
449 {
450 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
451 bool isCallValid =
452 (context->skipValidation() || ValidateSecondaryColor3i(context, red, green, blue));
453 if (isCallValid)
454 {
455 context->secondaryColor3i(red, green, blue);
456 }
457 ANGLE_CAPTURE(SecondaryColor3i, isCallValid, context, red, green, blue);
458 }
459 }
460
SecondaryColor3iv(const GLint * v)461 void GL_APIENTRY SecondaryColor3iv(const GLint *v)
462 {
463 Context *context = GetValidGlobalContext();
464 EVENT("glSecondaryColor3iv", "context = %d, const GLint *v = 0x%016" PRIxPTR "", CID(context),
465 (uintptr_t)v);
466
467 if (context)
468 {
469 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
470 bool isCallValid = (context->skipValidation() || ValidateSecondaryColor3iv(context, v));
471 if (isCallValid)
472 {
473 context->secondaryColor3iv(v);
474 }
475 ANGLE_CAPTURE(SecondaryColor3iv, isCallValid, context, v);
476 }
477 }
478
SecondaryColor3s(GLshort red,GLshort green,GLshort blue)479 void GL_APIENTRY SecondaryColor3s(GLshort red, GLshort green, GLshort blue)
480 {
481 Context *context = GetValidGlobalContext();
482 EVENT("glSecondaryColor3s",
483 "context = %d, GLshort red = %d, GLshort green = %d, GLshort blue = %d", CID(context),
484 red, green, blue);
485
486 if (context)
487 {
488 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
489 bool isCallValid =
490 (context->skipValidation() || ValidateSecondaryColor3s(context, red, green, blue));
491 if (isCallValid)
492 {
493 context->secondaryColor3s(red, green, blue);
494 }
495 ANGLE_CAPTURE(SecondaryColor3s, isCallValid, context, red, green, blue);
496 }
497 }
498
SecondaryColor3sv(const GLshort * v)499 void GL_APIENTRY SecondaryColor3sv(const GLshort *v)
500 {
501 Context *context = GetValidGlobalContext();
502 EVENT("glSecondaryColor3sv", "context = %d, const GLshort *v = 0x%016" PRIxPTR "", CID(context),
503 (uintptr_t)v);
504
505 if (context)
506 {
507 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
508 bool isCallValid = (context->skipValidation() || ValidateSecondaryColor3sv(context, v));
509 if (isCallValid)
510 {
511 context->secondaryColor3sv(v);
512 }
513 ANGLE_CAPTURE(SecondaryColor3sv, isCallValid, context, v);
514 }
515 }
516
SecondaryColor3ub(GLubyte red,GLubyte green,GLubyte blue)517 void GL_APIENTRY SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
518 {
519 Context *context = GetValidGlobalContext();
520 EVENT("glSecondaryColor3ub",
521 "context = %d, GLubyte red = %d, GLubyte green = %d, GLubyte blue = %d", CID(context),
522 red, green, blue);
523
524 if (context)
525 {
526 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
527 bool isCallValid =
528 (context->skipValidation() || ValidateSecondaryColor3ub(context, red, green, blue));
529 if (isCallValid)
530 {
531 context->secondaryColor3ub(red, green, blue);
532 }
533 ANGLE_CAPTURE(SecondaryColor3ub, isCallValid, context, red, green, blue);
534 }
535 }
536
SecondaryColor3ubv(const GLubyte * v)537 void GL_APIENTRY SecondaryColor3ubv(const GLubyte *v)
538 {
539 Context *context = GetValidGlobalContext();
540 EVENT("glSecondaryColor3ubv", "context = %d, const GLubyte *v = 0x%016" PRIxPTR "",
541 CID(context), (uintptr_t)v);
542
543 if (context)
544 {
545 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
546 bool isCallValid = (context->skipValidation() || ValidateSecondaryColor3ubv(context, v));
547 if (isCallValid)
548 {
549 context->secondaryColor3ubv(v);
550 }
551 ANGLE_CAPTURE(SecondaryColor3ubv, isCallValid, context, v);
552 }
553 }
554
SecondaryColor3ui(GLuint red,GLuint green,GLuint blue)555 void GL_APIENTRY SecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
556 {
557 Context *context = GetValidGlobalContext();
558 EVENT("glSecondaryColor3ui",
559 "context = %d, GLuint red = %u, GLuint green = %u, GLuint blue = %u", CID(context), red,
560 green, blue);
561
562 if (context)
563 {
564 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
565 bool isCallValid =
566 (context->skipValidation() || ValidateSecondaryColor3ui(context, red, green, blue));
567 if (isCallValid)
568 {
569 context->secondaryColor3ui(red, green, blue);
570 }
571 ANGLE_CAPTURE(SecondaryColor3ui, isCallValid, context, red, green, blue);
572 }
573 }
574
SecondaryColor3uiv(const GLuint * v)575 void GL_APIENTRY SecondaryColor3uiv(const GLuint *v)
576 {
577 Context *context = GetValidGlobalContext();
578 EVENT("glSecondaryColor3uiv", "context = %d, const GLuint *v = 0x%016" PRIxPTR "", CID(context),
579 (uintptr_t)v);
580
581 if (context)
582 {
583 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
584 bool isCallValid = (context->skipValidation() || ValidateSecondaryColor3uiv(context, v));
585 if (isCallValid)
586 {
587 context->secondaryColor3uiv(v);
588 }
589 ANGLE_CAPTURE(SecondaryColor3uiv, isCallValid, context, v);
590 }
591 }
592
SecondaryColor3us(GLushort red,GLushort green,GLushort blue)593 void GL_APIENTRY SecondaryColor3us(GLushort red, GLushort green, GLushort blue)
594 {
595 Context *context = GetValidGlobalContext();
596 EVENT("glSecondaryColor3us",
597 "context = %d, GLushort red = %u, GLushort green = %u, GLushort blue = %u", CID(context),
598 red, green, blue);
599
600 if (context)
601 {
602 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
603 bool isCallValid =
604 (context->skipValidation() || ValidateSecondaryColor3us(context, red, green, blue));
605 if (isCallValid)
606 {
607 context->secondaryColor3us(red, green, blue);
608 }
609 ANGLE_CAPTURE(SecondaryColor3us, isCallValid, context, red, green, blue);
610 }
611 }
612
SecondaryColor3usv(const GLushort * v)613 void GL_APIENTRY SecondaryColor3usv(const GLushort *v)
614 {
615 Context *context = GetValidGlobalContext();
616 EVENT("glSecondaryColor3usv", "context = %d, const GLushort *v = 0x%016" PRIxPTR "",
617 CID(context), (uintptr_t)v);
618
619 if (context)
620 {
621 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
622 bool isCallValid = (context->skipValidation() || ValidateSecondaryColor3usv(context, v));
623 if (isCallValid)
624 {
625 context->secondaryColor3usv(v);
626 }
627 ANGLE_CAPTURE(SecondaryColor3usv, isCallValid, context, v);
628 }
629 }
630
SecondaryColorPointer(GLint size,GLenum type,GLsizei stride,const void * pointer)631 void GL_APIENTRY SecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
632 {
633 Context *context = GetValidGlobalContext();
634 EVENT("glSecondaryColorPointer",
635 "context = %d, GLint size = %d, GLenum type = %s, GLsizei stride = %d, const void "
636 "*pointer = 0x%016" PRIxPTR "",
637 CID(context), size, GLenumToString(GLenumGroup::ColorPointerType, type), stride,
638 (uintptr_t)pointer);
639
640 if (context)
641 {
642 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
643 bool isCallValid = (context->skipValidation() ||
644 ValidateSecondaryColorPointer(context, size, type, stride, pointer));
645 if (isCallValid)
646 {
647 context->secondaryColorPointer(size, type, stride, pointer);
648 }
649 ANGLE_CAPTURE(SecondaryColorPointer, isCallValid, context, size, type, stride, pointer);
650 }
651 }
652
WindowPos2d(GLdouble x,GLdouble y)653 void GL_APIENTRY WindowPos2d(GLdouble x, GLdouble y)
654 {
655 Context *context = GetValidGlobalContext();
656 EVENT("glWindowPos2d", "context = %d, GLdouble x = %f, GLdouble y = %f", CID(context), x, y);
657
658 if (context)
659 {
660 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
661 bool isCallValid = (context->skipValidation() || ValidateWindowPos2d(context, x, y));
662 if (isCallValid)
663 {
664 context->windowPos2d(x, y);
665 }
666 ANGLE_CAPTURE(WindowPos2d, isCallValid, context, x, y);
667 }
668 }
669
WindowPos2dv(const GLdouble * v)670 void GL_APIENTRY WindowPos2dv(const GLdouble *v)
671 {
672 Context *context = GetValidGlobalContext();
673 EVENT("glWindowPos2dv", "context = %d, const GLdouble *v = 0x%016" PRIxPTR "", CID(context),
674 (uintptr_t)v);
675
676 if (context)
677 {
678 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
679 bool isCallValid = (context->skipValidation() || ValidateWindowPos2dv(context, v));
680 if (isCallValid)
681 {
682 context->windowPos2dv(v);
683 }
684 ANGLE_CAPTURE(WindowPos2dv, isCallValid, context, v);
685 }
686 }
687
WindowPos2f(GLfloat x,GLfloat y)688 void GL_APIENTRY WindowPos2f(GLfloat x, GLfloat y)
689 {
690 Context *context = GetValidGlobalContext();
691 EVENT("glWindowPos2f", "context = %d, GLfloat x = %f, GLfloat y = %f", CID(context), x, y);
692
693 if (context)
694 {
695 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
696 bool isCallValid = (context->skipValidation() || ValidateWindowPos2f(context, x, y));
697 if (isCallValid)
698 {
699 context->windowPos2f(x, y);
700 }
701 ANGLE_CAPTURE(WindowPos2f, isCallValid, context, x, y);
702 }
703 }
704
WindowPos2fv(const GLfloat * v)705 void GL_APIENTRY WindowPos2fv(const GLfloat *v)
706 {
707 Context *context = GetValidGlobalContext();
708 EVENT("glWindowPos2fv", "context = %d, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
709 (uintptr_t)v);
710
711 if (context)
712 {
713 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
714 bool isCallValid = (context->skipValidation() || ValidateWindowPos2fv(context, v));
715 if (isCallValid)
716 {
717 context->windowPos2fv(v);
718 }
719 ANGLE_CAPTURE(WindowPos2fv, isCallValid, context, v);
720 }
721 }
722
WindowPos2i(GLint x,GLint y)723 void GL_APIENTRY WindowPos2i(GLint x, GLint y)
724 {
725 Context *context = GetValidGlobalContext();
726 EVENT("glWindowPos2i", "context = %d, GLint x = %d, GLint y = %d", CID(context), x, y);
727
728 if (context)
729 {
730 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
731 bool isCallValid = (context->skipValidation() || ValidateWindowPos2i(context, x, y));
732 if (isCallValid)
733 {
734 context->windowPos2i(x, y);
735 }
736 ANGLE_CAPTURE(WindowPos2i, isCallValid, context, x, y);
737 }
738 }
739
WindowPos2iv(const GLint * v)740 void GL_APIENTRY WindowPos2iv(const GLint *v)
741 {
742 Context *context = GetValidGlobalContext();
743 EVENT("glWindowPos2iv", "context = %d, const GLint *v = 0x%016" PRIxPTR "", CID(context),
744 (uintptr_t)v);
745
746 if (context)
747 {
748 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
749 bool isCallValid = (context->skipValidation() || ValidateWindowPos2iv(context, v));
750 if (isCallValid)
751 {
752 context->windowPos2iv(v);
753 }
754 ANGLE_CAPTURE(WindowPos2iv, isCallValid, context, v);
755 }
756 }
757
WindowPos2s(GLshort x,GLshort y)758 void GL_APIENTRY WindowPos2s(GLshort x, GLshort y)
759 {
760 Context *context = GetValidGlobalContext();
761 EVENT("glWindowPos2s", "context = %d, GLshort x = %d, GLshort y = %d", CID(context), x, y);
762
763 if (context)
764 {
765 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
766 bool isCallValid = (context->skipValidation() || ValidateWindowPos2s(context, x, y));
767 if (isCallValid)
768 {
769 context->windowPos2s(x, y);
770 }
771 ANGLE_CAPTURE(WindowPos2s, isCallValid, context, x, y);
772 }
773 }
774
WindowPos2sv(const GLshort * v)775 void GL_APIENTRY WindowPos2sv(const GLshort *v)
776 {
777 Context *context = GetValidGlobalContext();
778 EVENT("glWindowPos2sv", "context = %d, const GLshort *v = 0x%016" PRIxPTR "", CID(context),
779 (uintptr_t)v);
780
781 if (context)
782 {
783 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
784 bool isCallValid = (context->skipValidation() || ValidateWindowPos2sv(context, v));
785 if (isCallValid)
786 {
787 context->windowPos2sv(v);
788 }
789 ANGLE_CAPTURE(WindowPos2sv, isCallValid, context, v);
790 }
791 }
792
WindowPos3d(GLdouble x,GLdouble y,GLdouble z)793 void GL_APIENTRY WindowPos3d(GLdouble x, GLdouble y, GLdouble z)
794 {
795 Context *context = GetValidGlobalContext();
796 EVENT("glWindowPos3d", "context = %d, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f",
797 CID(context), x, y, z);
798
799 if (context)
800 {
801 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
802 bool isCallValid = (context->skipValidation() || ValidateWindowPos3d(context, x, y, z));
803 if (isCallValid)
804 {
805 context->windowPos3d(x, y, z);
806 }
807 ANGLE_CAPTURE(WindowPos3d, isCallValid, context, x, y, z);
808 }
809 }
810
WindowPos3dv(const GLdouble * v)811 void GL_APIENTRY WindowPos3dv(const GLdouble *v)
812 {
813 Context *context = GetValidGlobalContext();
814 EVENT("glWindowPos3dv", "context = %d, const GLdouble *v = 0x%016" PRIxPTR "", CID(context),
815 (uintptr_t)v);
816
817 if (context)
818 {
819 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
820 bool isCallValid = (context->skipValidation() || ValidateWindowPos3dv(context, v));
821 if (isCallValid)
822 {
823 context->windowPos3dv(v);
824 }
825 ANGLE_CAPTURE(WindowPos3dv, isCallValid, context, v);
826 }
827 }
828
WindowPos3f(GLfloat x,GLfloat y,GLfloat z)829 void GL_APIENTRY WindowPos3f(GLfloat x, GLfloat y, GLfloat z)
830 {
831 Context *context = GetValidGlobalContext();
832 EVENT("glWindowPos3f", "context = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f",
833 CID(context), x, y, z);
834
835 if (context)
836 {
837 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
838 bool isCallValid = (context->skipValidation() || ValidateWindowPos3f(context, x, y, z));
839 if (isCallValid)
840 {
841 context->windowPos3f(x, y, z);
842 }
843 ANGLE_CAPTURE(WindowPos3f, isCallValid, context, x, y, z);
844 }
845 }
846
WindowPos3fv(const GLfloat * v)847 void GL_APIENTRY WindowPos3fv(const GLfloat *v)
848 {
849 Context *context = GetValidGlobalContext();
850 EVENT("glWindowPos3fv", "context = %d, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
851 (uintptr_t)v);
852
853 if (context)
854 {
855 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
856 bool isCallValid = (context->skipValidation() || ValidateWindowPos3fv(context, v));
857 if (isCallValid)
858 {
859 context->windowPos3fv(v);
860 }
861 ANGLE_CAPTURE(WindowPos3fv, isCallValid, context, v);
862 }
863 }
864
WindowPos3i(GLint x,GLint y,GLint z)865 void GL_APIENTRY WindowPos3i(GLint x, GLint y, GLint z)
866 {
867 Context *context = GetValidGlobalContext();
868 EVENT("glWindowPos3i", "context = %d, GLint x = %d, GLint y = %d, GLint z = %d", CID(context),
869 x, y, z);
870
871 if (context)
872 {
873 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
874 bool isCallValid = (context->skipValidation() || ValidateWindowPos3i(context, x, y, z));
875 if (isCallValid)
876 {
877 context->windowPos3i(x, y, z);
878 }
879 ANGLE_CAPTURE(WindowPos3i, isCallValid, context, x, y, z);
880 }
881 }
882
WindowPos3iv(const GLint * v)883 void GL_APIENTRY WindowPos3iv(const GLint *v)
884 {
885 Context *context = GetValidGlobalContext();
886 EVENT("glWindowPos3iv", "context = %d, const GLint *v = 0x%016" PRIxPTR "", CID(context),
887 (uintptr_t)v);
888
889 if (context)
890 {
891 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
892 bool isCallValid = (context->skipValidation() || ValidateWindowPos3iv(context, v));
893 if (isCallValid)
894 {
895 context->windowPos3iv(v);
896 }
897 ANGLE_CAPTURE(WindowPos3iv, isCallValid, context, v);
898 }
899 }
900
WindowPos3s(GLshort x,GLshort y,GLshort z)901 void GL_APIENTRY WindowPos3s(GLshort x, GLshort y, GLshort z)
902 {
903 Context *context = GetValidGlobalContext();
904 EVENT("glWindowPos3s", "context = %d, GLshort x = %d, GLshort y = %d, GLshort z = %d",
905 CID(context), x, y, z);
906
907 if (context)
908 {
909 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
910 bool isCallValid = (context->skipValidation() || ValidateWindowPos3s(context, x, y, z));
911 if (isCallValid)
912 {
913 context->windowPos3s(x, y, z);
914 }
915 ANGLE_CAPTURE(WindowPos3s, isCallValid, context, x, y, z);
916 }
917 }
918
WindowPos3sv(const GLshort * v)919 void GL_APIENTRY WindowPos3sv(const GLshort *v)
920 {
921 Context *context = GetValidGlobalContext();
922 EVENT("glWindowPos3sv", "context = %d, const GLshort *v = 0x%016" PRIxPTR "", CID(context),
923 (uintptr_t)v);
924
925 if (context)
926 {
927 std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
928 bool isCallValid = (context->skipValidation() || ValidateWindowPos3sv(context, v));
929 if (isCallValid)
930 {
931 context->windowPos3sv(v);
932 }
933 ANGLE_CAPTURE(WindowPos3sv, isCallValid, context, v);
934 }
935 }
936 } // namespace gl
937