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