1 //
2 // Copyright(c) 2014 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 
7 // entry_points_gles_2_0_ext.cpp : Implements the GLES 2.0 extension entry points.
8 
9 #include "libGLESv2/entry_points_gles_2_0_ext.h"
10 #include "libGLESv2/global_state.h"
11 
12 #include "libANGLE/Buffer.h"
13 #include "libANGLE/Context.h"
14 #include "libANGLE/Error.h"
15 #include "libANGLE/ErrorStrings.h"
16 #include "libANGLE/Fence.h"
17 #include "libANGLE/Framebuffer.h"
18 #include "libANGLE/Query.h"
19 #include "libANGLE/Shader.h"
20 #include "libANGLE/Thread.h"
21 #include "libANGLE/VertexArray.h"
22 #include "libANGLE/queryconversions.h"
23 #include "libANGLE/queryutils.h"
24 
25 #include "libANGLE/validationES.h"
26 #include "libANGLE/validationES2.h"
27 #include "libANGLE/validationES3.h"
28 #include "libANGLE/validationES31.h"
29 
30 #include "common/debug.h"
31 #include "common/utilities.h"
32 
33 namespace gl
34 {
35 
36 namespace
37 {
38 
SetRobustLengthParam(GLsizei * length,GLsizei value)39 void SetRobustLengthParam(GLsizei *length, GLsizei value)
40 {
41     if (length)
42     {
43         *length = value;
44     }
45 }
46 
47 }  // anonymous namespace
48 
GenQueriesEXT(GLsizei n,GLuint * ids)49 void GL_APIENTRY GenQueriesEXT(GLsizei n, GLuint *ids)
50 {
51     EVENT("(GLsizei n = %d, GLuint* ids = 0x%0.8p)", n, ids);
52 
53     Context *context = GetValidGlobalContext();
54     if (context)
55     {
56         if (!context->skipValidation() && !ValidateGenQueriesEXT(context, n, ids))
57         {
58             return;
59         }
60 
61         context->genQueries(n, ids);
62     }
63 }
64 
DeleteQueriesEXT(GLsizei n,const GLuint * ids)65 void GL_APIENTRY DeleteQueriesEXT(GLsizei n, const GLuint *ids)
66 {
67     EVENT("(GLsizei n = %d, const GLuint *ids = 0x%0.8p)", n, ids);
68 
69     Context *context = GetValidGlobalContext();
70     if (context)
71     {
72         if (!context->skipValidation() && !ValidateDeleteQueriesEXT(context, n, ids))
73         {
74             return;
75         }
76 
77         context->deleteQueries(n, ids);
78     }
79 }
80 
IsQueryEXT(GLuint id)81 GLboolean GL_APIENTRY IsQueryEXT(GLuint id)
82 {
83     EVENT("(GLuint id = %d)", id);
84 
85     Context *context = GetValidGlobalContext();
86     if (context)
87     {
88         if (!context->skipValidation() && !ValidateIsQueryEXT(context, id))
89         {
90             return GL_FALSE;
91         }
92 
93         return context->isQuery(id);
94     }
95 
96     return GL_FALSE;
97 }
98 
BeginQueryEXT(GLenum target,GLuint id)99 void GL_APIENTRY BeginQueryEXT(GLenum target, GLuint id)
100 {
101     EVENT("(GLenum target = 0x%X, GLuint %d)", target, id);
102 
103     Context *context = GetValidGlobalContext();
104     if (context)
105     {
106         if (!context->skipValidation() && !ValidateBeginQueryEXT(context, target, id))
107         {
108             return;
109         }
110 
111         context->beginQuery(target, id);
112     }
113 }
114 
EndQueryEXT(GLenum target)115 void GL_APIENTRY EndQueryEXT(GLenum target)
116 {
117     EVENT("GLenum target = 0x%X)", target);
118 
119     Context *context = GetValidGlobalContext();
120     if (context)
121     {
122         if (!context->skipValidation() && !ValidateEndQueryEXT(context, target))
123         {
124             return;
125         }
126 
127         context->endQuery(target);
128     }
129 }
130 
QueryCounterEXT(GLuint id,GLenum target)131 void GL_APIENTRY QueryCounterEXT(GLuint id, GLenum target)
132 {
133     EVENT("GLuint id = %d, GLenum target = 0x%X)", id, target);
134 
135     Context *context = GetValidGlobalContext();
136     if (context)
137     {
138         if (!context->skipValidation() && !ValidateQueryCounterEXT(context, id, target))
139         {
140             return;
141         }
142 
143         context->queryCounter(id, target);
144     }
145 }
146 
GetQueryivEXT(GLenum target,GLenum pname,GLint * params)147 void GL_APIENTRY GetQueryivEXT(GLenum target, GLenum pname, GLint *params)
148 {
149     EVENT("GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", target, pname,
150           params);
151 
152     Context *context = GetValidGlobalContext();
153     if (context)
154     {
155         if (!ValidateGetQueryivEXT(context, target, pname, params))
156         {
157             return;
158         }
159 
160         context->getQueryiv(target, pname, params);
161     }
162 }
163 
GetQueryObjectivEXT(GLuint id,GLenum pname,GLint * params)164 void GL_APIENTRY GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params)
165 {
166     EVENT("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.8p)", id, pname, params);
167 
168     Context *context = GetValidGlobalContext();
169     if (context)
170     {
171         if (!ValidateGetQueryObjectivEXT(context, id, pname, params))
172         {
173             return;
174         }
175 
176         context->getQueryObjectiv(id, pname, params);
177     }
178 }
179 
GetQueryObjectuivEXT(GLuint id,GLenum pname,GLuint * params)180 void GL_APIENTRY GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
181 {
182     EVENT("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.8p)", id, pname, params);
183 
184     Context *context = GetValidGlobalContext();
185     if (context)
186     {
187         if (!ValidateGetQueryObjectuivEXT(context, id, pname, params))
188         {
189             return;
190         }
191 
192         context->getQueryObjectuiv(id, pname, params);
193     }
194 }
195 
GetQueryObjecti64vEXT(GLuint id,GLenum pname,GLint64 * params)196 void GL_APIENTRY GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
197 {
198     EVENT("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.16p)", id, pname, params);
199 
200     Context *context = GetValidGlobalContext();
201     if (context)
202     {
203         if (!ValidateGetQueryObjecti64vEXT(context, id, pname, params))
204         {
205             return;
206         }
207 
208         context->getQueryObjecti64v(id, pname, params);
209     }
210 }
211 
GetQueryObjectui64vEXT(GLuint id,GLenum pname,GLuint64 * params)212 void GL_APIENTRY GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params)
213 {
214     EVENT("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.16p)", id, pname, params);
215 
216     Context *context = GetValidGlobalContext();
217     if (context)
218     {
219         if (!ValidateGetQueryObjectui64vEXT(context, id, pname, params))
220         {
221             return;
222         }
223 
224         context->getQueryObjectui64v(id, pname, params);
225     }
226 }
227 
DeleteFencesNV(GLsizei n,const GLuint * fences)228 void GL_APIENTRY DeleteFencesNV(GLsizei n, const GLuint *fences)
229 {
230     EVENT("(GLsizei n = %d, const GLuint* fences = 0x%0.8p)", n, fences);
231 
232     Context *context = GetValidGlobalContext();
233     if (context)
234     {
235         if (n < 0)
236         {
237             context->handleError(InvalidValue());
238             return;
239         }
240 
241         for (int i = 0; i < n; i++)
242         {
243             context->deleteFenceNV(fences[i]);
244         }
245     }
246 }
247 
DrawArraysInstancedANGLE(GLenum mode,GLint first,GLsizei count,GLsizei primcount)248 void GL_APIENTRY DrawArraysInstancedANGLE(GLenum mode,
249                                           GLint first,
250                                           GLsizei count,
251                                           GLsizei primcount)
252 {
253     EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d, GLsizei primcount = %d)",
254           mode, first, count, primcount);
255 
256     Context *context = GetValidGlobalContext();
257     if (context)
258     {
259         if (!ValidateDrawArraysInstancedANGLE(context, mode, first, count, primcount))
260         {
261             return;
262         }
263 
264         context->drawArraysInstanced(mode, first, count, primcount);
265     }
266 }
267 
DrawElementsInstancedANGLE(GLenum mode,GLsizei count,GLenum type,const void * indices,GLsizei primcount)268 void GL_APIENTRY DrawElementsInstancedANGLE(GLenum mode,
269                                             GLsizei count,
270                                             GLenum type,
271                                             const void *indices,
272                                             GLsizei primcount)
273 {
274     EVENT(
275         "(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const void* indices = "
276         "0x%0.8p, GLsizei primcount = %d)",
277         mode, count, type, indices, primcount);
278 
279     Context *context = GetValidGlobalContext();
280     if (context)
281     {
282         context->gatherParams<EntryPoint::DrawElementsInstancedANGLE>(mode, count, type, indices,
283                                                                       primcount);
284 
285         if (!context->skipValidation() &&
286             !ValidateDrawElementsInstancedANGLE(context, mode, count, type, indices, primcount))
287         {
288             return;
289         }
290 
291         context->drawElementsInstanced(mode, count, type, indices, primcount);
292     }
293 }
294 
FinishFenceNV(GLuint fence)295 void GL_APIENTRY FinishFenceNV(GLuint fence)
296 {
297     EVENT("(GLuint fence = %d)", fence);
298 
299     Context *context = GetValidGlobalContext();
300     if (context)
301     {
302         FenceNV *fenceObject = context->getFenceNV(fence);
303 
304         if (fenceObject == nullptr)
305         {
306             context->handleError(InvalidOperation());
307             return;
308         }
309 
310         if (fenceObject->isSet() != GL_TRUE)
311         {
312             context->handleError(InvalidOperation());
313             return;
314         }
315 
316         context->handleError(fenceObject->finish());
317     }
318 }
319 
GenFencesNV(GLsizei n,GLuint * fences)320 void GL_APIENTRY GenFencesNV(GLsizei n, GLuint *fences)
321 {
322     EVENT("(GLsizei n = %d, GLuint* fences = 0x%0.8p)", n, fences);
323 
324     Context *context = GetValidGlobalContext();
325     if (context)
326     {
327         if (n < 0)
328         {
329             context->handleError(InvalidValue());
330             return;
331         }
332 
333         for (int i = 0; i < n; i++)
334         {
335             fences[i] = context->createFenceNV();
336         }
337     }
338 }
339 
GetFenceivNV(GLuint fence,GLenum pname,GLint * params)340 void GL_APIENTRY GetFenceivNV(GLuint fence, GLenum pname, GLint *params)
341 {
342     EVENT("(GLuint fence = %d, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", fence, pname,
343           params);
344 
345     Context *context = GetValidGlobalContext();
346     if (context)
347     {
348         FenceNV *fenceObject = context->getFenceNV(fence);
349 
350         if (fenceObject == nullptr)
351         {
352             context->handleError(InvalidOperation());
353             return;
354         }
355 
356         if (fenceObject->isSet() != GL_TRUE)
357         {
358             context->handleError(InvalidOperation());
359             return;
360         }
361 
362         switch (pname)
363         {
364             case GL_FENCE_STATUS_NV:
365             {
366                 // GL_NV_fence spec:
367                 // Once the status of a fence has been finished (via FinishFenceNV) or tested and
368                 // the returned status is TRUE (via either TestFenceNV or GetFenceivNV querying the
369                 // FENCE_STATUS_NV), the status remains TRUE until the next SetFenceNV of the fence.
370                 GLboolean status = GL_TRUE;
371                 if (fenceObject->getStatus() != GL_TRUE)
372                 {
373                     Error error = fenceObject->test(&status);
374                     if (error.isError())
375                     {
376                         context->handleError(error);
377                         return;
378                     }
379                 }
380                 *params = status;
381                 break;
382             }
383 
384             case GL_FENCE_CONDITION_NV:
385             {
386                 *params = static_cast<GLint>(fenceObject->getCondition());
387                 break;
388             }
389 
390             default:
391             {
392                 context->handleError(InvalidEnum());
393                 return;
394             }
395         }
396     }
397 }
398 
GetGraphicsResetStatusEXT(void)399 GLenum GL_APIENTRY GetGraphicsResetStatusEXT(void)
400 {
401     EVENT("()");
402 
403     Context *context = GetGlobalContext();
404 
405     if (context)
406     {
407         return context->getResetStatus();
408     }
409 
410     return GL_NO_ERROR;
411 }
412 
GetTranslatedShaderSourceANGLE(GLuint shader,GLsizei bufsize,GLsizei * length,GLchar * source)413 void GL_APIENTRY GetTranslatedShaderSourceANGLE(GLuint shader,
414                                                 GLsizei bufsize,
415                                                 GLsizei *length,
416                                                 GLchar *source)
417 {
418     EVENT(
419         "(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* source = "
420         "0x%0.8p)",
421         shader, bufsize, length, source);
422 
423     Context *context = GetValidGlobalContext();
424     if (context)
425     {
426         if (bufsize < 0)
427         {
428             context->handleError(InvalidValue());
429             return;
430         }
431 
432         Shader *shaderObject = context->getShader(shader);
433 
434         if (!shaderObject)
435         {
436             context->handleError(InvalidOperation());
437             return;
438         }
439 
440         shaderObject->getTranslatedSourceWithDebugInfo(context, bufsize, length, source);
441     }
442 }
443 
GetnUniformfvEXT(GLuint program,GLint location,GLsizei bufSize,GLfloat * params)444 void GL_APIENTRY GetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
445 {
446     EVENT(
447         "(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLfloat* params = "
448         "0x%0.8p)",
449         program, location, bufSize, params);
450 
451     Context *context = GetValidGlobalContext();
452     if (context)
453     {
454         if (!ValidateGetnUniformfvEXT(context, program, location, bufSize, params))
455         {
456             return;
457         }
458 
459         Program *programObject = context->getProgram(program);
460         ASSERT(programObject);
461 
462         programObject->getUniformfv(context, location, params);
463     }
464 }
465 
GetnUniformivEXT(GLuint program,GLint location,GLsizei bufSize,GLint * params)466 void GL_APIENTRY GetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params)
467 {
468     EVENT(
469         "(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLint* params = 0x%0.8p)",
470         program, location, bufSize, params);
471 
472     Context *context = GetValidGlobalContext();
473     if (context)
474     {
475         if (!ValidateGetnUniformivEXT(context, program, location, bufSize, params))
476         {
477             return;
478         }
479 
480         Program *programObject = context->getProgram(program);
481         ASSERT(programObject);
482 
483         programObject->getUniformiv(context, location, params);
484     }
485 }
486 
IsFenceNV(GLuint fence)487 GLboolean GL_APIENTRY IsFenceNV(GLuint fence)
488 {
489     EVENT("(GLuint fence = %d)", fence);
490 
491     Context *context = GetValidGlobalContext();
492     if (context)
493     {
494         FenceNV *fenceObject = context->getFenceNV(fence);
495 
496         if (fenceObject == nullptr)
497         {
498             return GL_FALSE;
499         }
500 
501         // GL_NV_fence spec:
502         // A name returned by GenFencesNV, but not yet set via SetFenceNV, is not the name of an
503         // existing fence.
504         return fenceObject->isSet();
505     }
506 
507     return GL_FALSE;
508 }
509 
ReadnPixelsEXT(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void * data)510 void GL_APIENTRY ReadnPixelsEXT(GLint x,
511                                 GLint y,
512                                 GLsizei width,
513                                 GLsizei height,
514                                 GLenum format,
515                                 GLenum type,
516                                 GLsizei bufSize,
517                                 void *data)
518 {
519     EVENT(
520         "(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
521         "GLenum format = 0x%X, GLenum type = 0x%X, GLsizei bufSize = 0x%d, void *data = 0x%0.8p)",
522         x, y, width, height, format, type, bufSize, data);
523 
524     Context *context = GetValidGlobalContext();
525     if (context)
526     {
527         if (!context->skipValidation() &&
528             !ValidateReadnPixelsEXT(context, x, y, width, height, format, type, bufSize, data))
529         {
530             return;
531         }
532 
533         context->readPixels(x, y, width, height, format, type, data);
534     }
535 }
536 
RenderbufferStorageMultisampleANGLE(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)537 void GL_APIENTRY RenderbufferStorageMultisampleANGLE(GLenum target,
538                                                      GLsizei samples,
539                                                      GLenum internalformat,
540                                                      GLsizei width,
541                                                      GLsizei height)
542 {
543     EVENT(
544         "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width "
545         "= %d, GLsizei height = %d)",
546         target, samples, internalformat, width, height);
547 
548     Context *context = GetValidGlobalContext();
549     if (context)
550     {
551         if (!context->skipValidation() &&
552             !ValidateRenderbufferStorageMultisampleANGLE(context, target, samples, internalformat,
553                                                          width, height))
554         {
555             return;
556         }
557 
558         context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
559     }
560 }
561 
SetFenceNV(GLuint fence,GLenum condition)562 void GL_APIENTRY SetFenceNV(GLuint fence, GLenum condition)
563 {
564     EVENT("(GLuint fence = %d, GLenum condition = 0x%X)", fence, condition);
565 
566     Context *context = GetValidGlobalContext();
567     if (context)
568     {
569         if (condition != GL_ALL_COMPLETED_NV)
570         {
571             context->handleError(InvalidEnum());
572             return;
573         }
574 
575         FenceNV *fenceObject = context->getFenceNV(fence);
576 
577         if (fenceObject == nullptr)
578         {
579             context->handleError(InvalidOperation());
580             return;
581         }
582 
583         Error error = fenceObject->set(condition);
584         if (error.isError())
585         {
586             context->handleError(error);
587             return;
588         }
589     }
590 }
591 
TestFenceNV(GLuint fence)592 GLboolean GL_APIENTRY TestFenceNV(GLuint fence)
593 {
594     EVENT("(GLuint fence = %d)", fence);
595 
596     Context *context = GetValidGlobalContext();
597     if (context)
598     {
599         FenceNV *fenceObject = context->getFenceNV(fence);
600 
601         if (fenceObject == nullptr)
602         {
603             context->handleError(InvalidOperation());
604             return GL_TRUE;
605         }
606 
607         if (fenceObject->isSet() != GL_TRUE)
608         {
609             context->handleError(InvalidOperation());
610             return GL_TRUE;
611         }
612 
613         GLboolean result;
614         Error error = fenceObject->test(&result);
615         if (error.isError())
616         {
617             context->handleError(error);
618             return GL_TRUE;
619         }
620 
621         return result;
622     }
623 
624     return GL_TRUE;
625 }
626 
627 void GL_APIENTRY
TexStorage2DEXT(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)628 TexStorage2DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
629 {
630     EVENT(
631         "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = "
632         "%d, GLsizei height = %d)",
633         target, levels, internalformat, width, height);
634 
635     Context *context = GetValidGlobalContext();
636     if (context)
637     {
638         if (!context->getExtensions().textureStorage)
639         {
640             context->handleError(InvalidOperation());
641             return;
642         }
643 
644         if (context->getClientMajorVersion() < 3 &&
645             !ValidateES2TexStorageParameters(context, target, levels, internalformat, width,
646                                              height))
647         {
648             return;
649         }
650 
651         if (context->getClientMajorVersion() >= 3 &&
652             !ValidateES3TexStorage2DParameters(context, target, levels, internalformat, width,
653                                                height, 1))
654         {
655             return;
656         }
657 
658         context->texStorage2D(target, levels, internalformat, width, height);
659     }
660 }
661 
VertexAttribDivisorANGLE(GLuint index,GLuint divisor)662 void GL_APIENTRY VertexAttribDivisorANGLE(GLuint index, GLuint divisor)
663 {
664     EVENT("(GLuint index = %d, GLuint divisor = %d)", index, divisor);
665 
666     Context *context = GetValidGlobalContext();
667     if (context)
668     {
669         if (!context->getExtensions().instancedArrays)
670         {
671             ANGLE_VALIDATION_ERR(context, InvalidOperation(), ExtensionNotEnabled);
672             return;
673         }
674 
675         if (index >= MAX_VERTEX_ATTRIBS)
676         {
677             context->handleError(InvalidValue());
678             return;
679         }
680 
681         if (context->getLimitations().attributeZeroRequiresZeroDivisorInEXT)
682         {
683             if (index == 0 && divisor != 0)
684             {
685                 const char *errorMessage =
686                     "The current context doesn't support setting a non-zero divisor on the "
687                     "attribute with index zero. "
688                     "Please reorder the attributes in your vertex shader so that attribute zero "
689                     "can have a zero divisor.";
690                 context->handleError(InvalidOperation() << errorMessage);
691 
692                 // We also output an error message to the debugger window if tracing is active, so
693                 // that developers can see the error message.
694                 ERR() << errorMessage;
695 
696                 return;
697             }
698         }
699 
700         context->vertexAttribDivisor(index, divisor);
701     }
702 }
703 
BlitFramebufferANGLE(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)704 void GL_APIENTRY BlitFramebufferANGLE(GLint srcX0,
705                                       GLint srcY0,
706                                       GLint srcX1,
707                                       GLint srcY1,
708                                       GLint dstX0,
709                                       GLint dstY0,
710                                       GLint dstX1,
711                                       GLint dstY1,
712                                       GLbitfield mask,
713                                       GLenum filter)
714 {
715     EVENT(
716         "(GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, "
717         "GLint dstX0 = %d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, "
718         "GLbitfield mask = 0x%X, GLenum filter = 0x%X)",
719         srcX0, srcY0, srcX1, srcX1, dstX0, dstY0, dstX1, dstY1, mask, filter);
720 
721     Context *context = GetValidGlobalContext();
722     if (context)
723     {
724         if (!context->skipValidation() &&
725             !ValidateBlitFramebufferANGLE(context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
726                                           dstY1, mask, filter))
727         {
728             return;
729         }
730 
731         context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
732                                  filter);
733     }
734 }
735 
DiscardFramebufferEXT(GLenum target,GLsizei numAttachments,const GLenum * attachments)736 void GL_APIENTRY DiscardFramebufferEXT(GLenum target,
737                                        GLsizei numAttachments,
738                                        const GLenum *attachments)
739 {
740     EVENT("(GLenum target = 0x%X, GLsizei numAttachments = %d, attachments = 0x%0.8p)", target,
741           numAttachments, attachments);
742 
743     Context *context = GetValidGlobalContext();
744     if (context)
745     {
746         if (!context->skipValidation() &&
747             !ValidateDiscardFramebufferEXT(context, target, numAttachments, attachments))
748         {
749             return;
750         }
751 
752         context->discardFramebuffer(target, numAttachments, attachments);
753     }
754 }
755 
TexImage3DOES(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void * pixels)756 void GL_APIENTRY TexImage3DOES(GLenum target,
757                                GLint level,
758                                GLenum internalformat,
759                                GLsizei width,
760                                GLsizei height,
761                                GLsizei depth,
762                                GLint border,
763                                GLenum format,
764                                GLenum type,
765                                const void *pixels)
766 {
767     EVENT(
768         "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, "
769         "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, "
770         "GLenum format = 0x%X, GLenum type = 0x%x, const void* pixels = 0x%0.8p)",
771         target, level, internalformat, width, height, depth, border, format, type, pixels);
772 
773     UNIMPLEMENTED();  // FIXME
774 }
775 
GetProgramBinaryOES(GLuint program,GLsizei bufSize,GLsizei * length,GLenum * binaryFormat,void * binary)776 void GL_APIENTRY GetProgramBinaryOES(GLuint program,
777                                      GLsizei bufSize,
778                                      GLsizei *length,
779                                      GLenum *binaryFormat,
780                                      void *binary)
781 {
782     EVENT(
783         "(GLenum program = 0x%X, bufSize = %d, length = 0x%0.8p, binaryFormat = 0x%0.8p, binary = "
784         "0x%0.8p)",
785         program, bufSize, length, binaryFormat, binary);
786 
787     Context *context = GetValidGlobalContext();
788     if (context)
789     {
790         if (!context->skipValidation() &&
791             !ValidateGetProgramBinaryOES(context, program, bufSize, length, binaryFormat, binary))
792         {
793             return;
794         }
795 
796         context->getProgramBinary(program, bufSize, length, binaryFormat, binary);
797     }
798 }
799 
ProgramBinaryOES(GLuint program,GLenum binaryFormat,const void * binary,GLint length)800 void GL_APIENTRY ProgramBinaryOES(GLuint program,
801                                   GLenum binaryFormat,
802                                   const void *binary,
803                                   GLint length)
804 {
805     EVENT("(GLenum program = 0x%X, binaryFormat = 0x%x, binary = 0x%0.8p, length = %d)", program,
806           binaryFormat, binary, length);
807 
808     Context *context = GetValidGlobalContext();
809     if (context)
810     {
811         if (!context->skipValidation() &&
812             !ValidateProgramBinaryOES(context, program, binaryFormat, binary, length))
813         {
814             return;
815         }
816 
817         context->programBinary(program, binaryFormat, binary, length);
818     }
819 }
820 
DrawBuffersEXT(GLsizei n,const GLenum * bufs)821 void GL_APIENTRY DrawBuffersEXT(GLsizei n, const GLenum *bufs)
822 {
823     EVENT("(GLenum n = %d, bufs = 0x%0.8p)", n, bufs);
824 
825     Context *context = GetValidGlobalContext();
826     if (context)
827     {
828         if (!context->skipValidation() && !ValidateDrawBuffersEXT(context, n, bufs))
829         {
830             return;
831         }
832 
833         context->drawBuffers(n, bufs);
834     }
835 }
836 
GetBufferPointervOES(GLenum target,GLenum pname,void ** params)837 void GL_APIENTRY GetBufferPointervOES(GLenum target, GLenum pname, void **params)
838 {
839     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, void** params = 0x%0.8p)", target, pname,
840           params);
841 
842     Context *context = GetValidGlobalContext();
843     if (context)
844     {
845         BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
846 
847         if (!context->skipValidation() &&
848             !ValidateGetBufferPointervOES(context, targetPacked, pname, params))
849         {
850             return;
851         }
852 
853         context->getBufferPointerv(targetPacked, pname, params);
854     }
855 }
856 
MapBufferOES(GLenum target,GLenum access)857 void *GL_APIENTRY MapBufferOES(GLenum target, GLenum access)
858 {
859     EVENT("(GLenum target = 0x%X, GLbitfield access = 0x%X)", target, access);
860 
861     Context *context = GetValidGlobalContext();
862     if (context)
863     {
864         BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
865 
866         if (!context->skipValidation() && !ValidateMapBufferOES(context, targetPacked, access))
867         {
868             return nullptr;
869         }
870 
871         return context->mapBuffer(targetPacked, access);
872     }
873 
874     return nullptr;
875 }
876 
UnmapBufferOES(GLenum target)877 GLboolean GL_APIENTRY UnmapBufferOES(GLenum target)
878 {
879     EVENT("(GLenum target = 0x%X)", target);
880 
881     Context *context = GetValidGlobalContext();
882     if (context)
883     {
884         BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
885 
886         if (!context->skipValidation() && !ValidateUnmapBufferOES(context, targetPacked))
887         {
888             return GL_FALSE;
889         }
890 
891         return context->unmapBuffer(targetPacked);
892     }
893 
894     return GL_FALSE;
895 }
896 
MapBufferRangeEXT(GLenum target,GLintptr offset,GLsizeiptr length,GLbitfield access)897 void *GL_APIENTRY MapBufferRangeEXT(GLenum target,
898                                     GLintptr offset,
899                                     GLsizeiptr length,
900                                     GLbitfield access)
901 {
902     EVENT(
903         "(GLenum target = 0x%X, GLintptr offset = %d, GLsizeiptr length = %d, GLbitfield access = "
904         "0x%X)",
905         target, offset, length, access);
906 
907     Context *context = GetValidGlobalContext();
908     if (context)
909     {
910         BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
911 
912         if (!context->skipValidation() &&
913             !ValidateMapBufferRangeEXT(context, targetPacked, offset, length, access))
914         {
915             return nullptr;
916         }
917 
918         return context->mapBufferRange(targetPacked, offset, length, access);
919     }
920 
921     return nullptr;
922 }
923 
FlushMappedBufferRangeEXT(GLenum target,GLintptr offset,GLsizeiptr length)924 void GL_APIENTRY FlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length)
925 {
926     EVENT("(GLenum target = 0x%X, GLintptr offset = %d, GLsizeiptr length = %d)", target, offset,
927           length);
928 
929     Context *context = GetValidGlobalContext();
930     if (context)
931     {
932         BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
933 
934         if (!context->skipValidation() &&
935             !ValidateFlushMappedBufferRangeEXT(context, targetPacked, offset, length))
936         {
937             return;
938         }
939 
940         context->flushMappedBufferRange(targetPacked, offset, length);
941     }
942 }
943 
InsertEventMarkerEXT(GLsizei length,const char * marker)944 void GL_APIENTRY InsertEventMarkerEXT(GLsizei length, const char *marker)
945 {
946     // Don't run an EVENT() macro on the EXT_debug_marker entry points.
947     // It can interfere with the debug events being set by the caller.
948 
949     Context *context = GetValidGlobalContext();
950     if (context)
951     {
952         if (!context->getExtensions().debugMarker)
953         {
954             // The debug marker calls should not set error state
955             // However, it seems reasonable to set an error state if the extension is not enabled
956             context->handleError(InvalidOperation() << "Extension not enabled");
957             return;
958         }
959 
960         if (!ValidateInsertEventMarkerEXT(context, length, marker))
961         {
962             return;
963         }
964 
965         context->insertEventMarker(length, marker);
966     }
967 }
968 
PushGroupMarkerEXT(GLsizei length,const char * marker)969 void GL_APIENTRY PushGroupMarkerEXT(GLsizei length, const char *marker)
970 {
971     // Don't run an EVENT() macro on the EXT_debug_marker entry points.
972     // It can interfere with the debug events being set by the caller.
973 
974     Context *context = GetValidGlobalContext();
975     if (context)
976     {
977         if (!context->getExtensions().debugMarker)
978         {
979             // The debug marker calls should not set error state
980             // However, it seems reasonable to set an error state if the extension is not enabled
981             context->handleError(InvalidOperation() << "Extension not enabled");
982             return;
983         }
984 
985         if (!ValidatePushGroupMarkerEXT(context, length, marker))
986         {
987             return;
988         }
989 
990         if (marker == nullptr)
991         {
992             // From the EXT_debug_marker spec,
993             // "If <marker> is null then an empty string is pushed on the stack."
994             context->pushGroupMarker(length, "");
995         }
996         else
997         {
998             context->pushGroupMarker(length, marker);
999         }
1000     }
1001 }
1002 
PopGroupMarkerEXT()1003 void GL_APIENTRY PopGroupMarkerEXT()
1004 {
1005     // Don't run an EVENT() macro on the EXT_debug_marker entry points.
1006     // It can interfere with the debug events being set by the caller.
1007 
1008     Context *context = GetValidGlobalContext();
1009     if (context)
1010     {
1011         if (!context->getExtensions().debugMarker)
1012         {
1013             // The debug marker calls should not set error state
1014             // However, it seems reasonable to set an error state if the extension is not enabled
1015             context->handleError(InvalidOperation() << "Extension not enabled");
1016             return;
1017         }
1018 
1019         context->popGroupMarker();
1020     }
1021 }
1022 
EGLImageTargetTexture2DOES(GLenum target,GLeglImageOES image)1023 ANGLE_EXPORT void GL_APIENTRY EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
1024 {
1025     EVENT("(GLenum target = 0x%X, GLeglImageOES image = 0x%0.8p)", target, image);
1026 
1027     Context *context = GetValidGlobalContext();
1028     if (context)
1029     {
1030         egl::Image *imageObject = reinterpret_cast<egl::Image *>(image);
1031         if (!ValidateEGLImageTargetTexture2DOES(context, target, imageObject))
1032         {
1033             return;
1034         }
1035 
1036         Texture *texture = context->getTargetTexture(target);
1037         Error error      = texture->setEGLImageTarget(context, target, imageObject);
1038         if (error.isError())
1039         {
1040             context->handleError(error);
1041             return;
1042         }
1043     }
1044 }
1045 
EGLImageTargetRenderbufferStorageOES(GLenum target,GLeglImageOES image)1046 ANGLE_EXPORT void GL_APIENTRY EGLImageTargetRenderbufferStorageOES(GLenum target,
1047                                                                    GLeglImageOES image)
1048 {
1049     EVENT("(GLenum target = 0x%X, GLeglImageOES image = 0x%0.8p)", target, image);
1050 
1051     Context *context = GetValidGlobalContext();
1052     if (context)
1053     {
1054         egl::Image *imageObject = reinterpret_cast<egl::Image *>(image);
1055         if (!ValidateEGLImageTargetRenderbufferStorageOES(context, target, imageObject))
1056         {
1057             return;
1058         }
1059 
1060         Renderbuffer *renderbuffer = context->getGLState().getCurrentRenderbuffer();
1061         Error error                = renderbuffer->setStorageEGLImageTarget(context, imageObject);
1062         if (error.isError())
1063         {
1064             context->handleError(error);
1065             return;
1066         }
1067     }
1068 }
1069 
BindVertexArrayOES(GLuint array)1070 void GL_APIENTRY BindVertexArrayOES(GLuint array)
1071 {
1072     EVENT("(GLuint array = %u)", array);
1073 
1074     Context *context = GetValidGlobalContext();
1075     if (context)
1076     {
1077         if (!context->skipValidation() && !ValidateBindVertexArrayOES(context, array))
1078         {
1079             return;
1080         }
1081 
1082         context->bindVertexArray(array);
1083     }
1084 }
1085 
DeleteVertexArraysOES(GLsizei n,const GLuint * arrays)1086 void GL_APIENTRY DeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
1087 {
1088     EVENT("(GLsizei n = %d, const GLuint* arrays = 0x%0.8p)", n, arrays);
1089 
1090     Context *context = GetValidGlobalContext();
1091     if (context)
1092     {
1093         if (!context->skipValidation() && !ValidateDeleteVertexArraysOES(context, n, arrays))
1094         {
1095             return;
1096         }
1097 
1098         context->deleteVertexArrays(n, arrays);
1099     }
1100 }
1101 
GenVertexArraysOES(GLsizei n,GLuint * arrays)1102 void GL_APIENTRY GenVertexArraysOES(GLsizei n, GLuint *arrays)
1103 {
1104     EVENT("(GLsizei n = %d, GLuint* arrays = 0x%0.8p)", n, arrays);
1105 
1106     Context *context = GetValidGlobalContext();
1107     if (context)
1108     {
1109         if (!context->skipValidation() && !ValidateGenVertexArraysOES(context, n, arrays))
1110         {
1111             return;
1112         }
1113 
1114         context->genVertexArrays(n, arrays);
1115     }
1116 }
1117 
IsVertexArrayOES(GLuint array)1118 GLboolean GL_APIENTRY IsVertexArrayOES(GLuint array)
1119 {
1120     EVENT("(GLuint array = %u)", array);
1121 
1122     Context *context = GetValidGlobalContext();
1123     if (context)
1124     {
1125         if (!context->skipValidation() && !ValidateIsVertexArrayOES(context, array))
1126         {
1127             return GL_FALSE;
1128         }
1129 
1130         return context->isVertexArray(array);
1131     }
1132 
1133     return GL_FALSE;
1134 }
1135 
DebugMessageControlKHR(GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint * ids,GLboolean enabled)1136 void GL_APIENTRY DebugMessageControlKHR(GLenum source,
1137                                         GLenum type,
1138                                         GLenum severity,
1139                                         GLsizei count,
1140                                         const GLuint *ids,
1141                                         GLboolean enabled)
1142 {
1143     EVENT(
1144         "(GLenum source = 0x%X, GLenum type = 0x%X, GLenum severity = 0x%X, GLsizei count = %d, "
1145         "GLint *ids = 0x%0.8p, GLboolean enabled = %d)",
1146         source, type, severity, count, ids, enabled);
1147 
1148     Context *context = GetValidGlobalContext();
1149     if (context)
1150     {
1151         if (!ValidateDebugMessageControlKHR(context, source, type, severity, count, ids, enabled))
1152         {
1153             return;
1154         }
1155 
1156         context->debugMessageControl(source, type, severity, count, ids, enabled);
1157     }
1158 }
1159 
DebugMessageInsertKHR(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar * buf)1160 void GL_APIENTRY DebugMessageInsertKHR(GLenum source,
1161                                        GLenum type,
1162                                        GLuint id,
1163                                        GLenum severity,
1164                                        GLsizei length,
1165                                        const GLchar *buf)
1166 {
1167     EVENT(
1168         "(GLenum source = 0x%X, GLenum type = 0x%X, GLint id = %d, GLenum severity = 0x%X, GLsizei "
1169         "length = %d, const GLchar *buf = 0x%0.8p)",
1170         source, type, id, severity, length, buf);
1171 
1172     Context *context = GetValidGlobalContext();
1173     if (context)
1174     {
1175         if (!ValidateDebugMessageInsertKHR(context, source, type, id, severity, length, buf))
1176         {
1177             return;
1178         }
1179 
1180         context->debugMessageInsert(source, type, id, severity, length, buf);
1181     }
1182 }
1183 
DebugMessageCallbackKHR(GLDEBUGPROCKHR callback,const void * userParam)1184 void GL_APIENTRY DebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void *userParam)
1185 {
1186     EVENT("(GLDEBUGPROCKHR callback = 0x%0.8p, const void *userParam = 0x%0.8p)", callback,
1187           userParam);
1188 
1189     Context *context = GetValidGlobalContext();
1190     if (context)
1191     {
1192         if (!ValidateDebugMessageCallbackKHR(context, callback, userParam))
1193         {
1194             return;
1195         }
1196 
1197         context->debugMessageCallback(callback, userParam);
1198     }
1199 }
1200 
GetDebugMessageLogKHR(GLuint count,GLsizei bufSize,GLenum * sources,GLenum * types,GLuint * ids,GLenum * severities,GLsizei * lengths,GLchar * messageLog)1201 GLuint GL_APIENTRY GetDebugMessageLogKHR(GLuint count,
1202                                          GLsizei bufSize,
1203                                          GLenum *sources,
1204                                          GLenum *types,
1205                                          GLuint *ids,
1206                                          GLenum *severities,
1207                                          GLsizei *lengths,
1208                                          GLchar *messageLog)
1209 {
1210     EVENT(
1211         "(GLsizei count = %d, GLsizei bufSize = %d, GLenum *sources, GLenum *types = 0x%0.8p, "
1212         "GLuint *ids = 0x%0.8p, GLenum *severities = 0x%0.8p, GLsizei *lengths = 0x%0.8p, GLchar "
1213         "*messageLog = 0x%0.8p)",
1214         count, bufSize, sources, types, ids, severities, lengths, messageLog);
1215 
1216     Context *context = GetValidGlobalContext();
1217     if (context)
1218     {
1219         if (!ValidateGetDebugMessageLogKHR(context, count, bufSize, sources, types, ids, severities,
1220                                            lengths, messageLog))
1221         {
1222             return 0;
1223         }
1224 
1225         return context->getDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths,
1226                                            messageLog);
1227     }
1228 
1229     return 0;
1230 }
1231 
PushDebugGroupKHR(GLenum source,GLuint id,GLsizei length,const GLchar * message)1232 void GL_APIENTRY PushDebugGroupKHR(GLenum source, GLuint id, GLsizei length, const GLchar *message)
1233 {
1234     EVENT(
1235         "(GLenum source = 0x%X, GLuint id = 0x%X, GLsizei length = %d, const GLchar *message = "
1236         "0x%0.8p)",
1237         source, id, length, message);
1238 
1239     Context *context = GetValidGlobalContext();
1240     if (context)
1241     {
1242         if (!ValidatePushDebugGroupKHR(context, source, id, length, message))
1243         {
1244             return;
1245         }
1246 
1247         std::string msg(message, (length > 0) ? static_cast<size_t>(length) : strlen(message));
1248         context->pushDebugGroup(source, id, length, message);
1249     }
1250 }
1251 
PopDebugGroupKHR(void)1252 void GL_APIENTRY PopDebugGroupKHR(void)
1253 {
1254     EVENT("()");
1255 
1256     Context *context = GetValidGlobalContext();
1257     if (context)
1258     {
1259         if (!ValidatePopDebugGroupKHR(context))
1260         {
1261             return;
1262         }
1263 
1264         context->popDebugGroup();
1265     }
1266 }
1267 
ObjectLabelKHR(GLenum identifier,GLuint name,GLsizei length,const GLchar * label)1268 void GL_APIENTRY ObjectLabelKHR(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
1269 {
1270     EVENT(
1271         "(GLenum identifier = 0x%X, GLuint name = %u, GLsizei length = %d, const GLchar *label = "
1272         "0x%0.8p)",
1273         identifier, name, length, label);
1274 
1275     Context *context = GetValidGlobalContext();
1276     if (context)
1277     {
1278         if (!ValidateObjectLabelKHR(context, identifier, name, length, label))
1279         {
1280             return;
1281         }
1282 
1283         context->objectLabel(identifier, name, length, label);
1284     }
1285 }
1286 
1287 void GL_APIENTRY
GetObjectLabelKHR(GLenum identifier,GLuint name,GLsizei bufSize,GLsizei * length,GLchar * label)1288 GetObjectLabelKHR(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
1289 {
1290     EVENT(
1291         "(GLenum identifier = 0x%X, GLuint name = %u, GLsizei bufSize = %d, GLsizei *length = "
1292         "0x%0.8p, GLchar *label = 0x%0.8p)",
1293         identifier, name, bufSize, length, label);
1294 
1295     Context *context = GetValidGlobalContext();
1296     if (context)
1297     {
1298         if (!ValidateGetObjectLabelKHR(context, identifier, name, bufSize, length, label))
1299         {
1300             return;
1301         }
1302 
1303         context->getObjectLabel(identifier, name, bufSize, length, label);
1304     }
1305 }
1306 
ObjectPtrLabelKHR(const void * ptr,GLsizei length,const GLchar * label)1307 void GL_APIENTRY ObjectPtrLabelKHR(const void *ptr, GLsizei length, const GLchar *label)
1308 {
1309     EVENT("(const void *ptr = 0x%0.8p, GLsizei length = %d, const GLchar *label = 0x%0.8p)", ptr,
1310           length, label);
1311 
1312     Context *context = GetValidGlobalContext();
1313     if (context)
1314     {
1315         if (!ValidateObjectPtrLabelKHR(context, ptr, length, label))
1316         {
1317             return;
1318         }
1319 
1320         context->objectPtrLabel(ptr, length, label);
1321     }
1322 }
1323 
GetObjectPtrLabelKHR(const void * ptr,GLsizei bufSize,GLsizei * length,GLchar * label)1324 void GL_APIENTRY GetObjectPtrLabelKHR(const void *ptr,
1325                                       GLsizei bufSize,
1326                                       GLsizei *length,
1327                                       GLchar *label)
1328 {
1329     EVENT(
1330         "(const void *ptr = 0x%0.8p, GLsizei bufSize = %d, GLsizei *length = 0x%0.8p, GLchar "
1331         "*label = 0x%0.8p)",
1332         ptr, bufSize, length, label);
1333 
1334     Context *context = GetValidGlobalContext();
1335     if (context)
1336     {
1337         if (!ValidateGetObjectPtrLabelKHR(context, ptr, bufSize, length, label))
1338         {
1339             return;
1340         }
1341 
1342         context->getObjectPtrLabel(ptr, bufSize, length, label);
1343     }
1344 }
1345 
GetPointervKHR(GLenum pname,void ** params)1346 void GL_APIENTRY GetPointervKHR(GLenum pname, void **params)
1347 {
1348     EVENT("(GLenum pname = 0x%X, void **params = 0x%0.8p)", pname, params);
1349 
1350     Context *context = GetValidGlobalContext();
1351     if (context)
1352     {
1353         if (!ValidateGetPointervKHR(context, pname, params))
1354         {
1355             return;
1356         }
1357 
1358         context->getPointerv(pname, params);
1359     }
1360 }
1361 
BindUniformLocationCHROMIUM(GLuint program,GLint location,const GLchar * name)1362 ANGLE_EXPORT void GL_APIENTRY BindUniformLocationCHROMIUM(GLuint program,
1363                                                           GLint location,
1364                                                           const GLchar *name)
1365 {
1366     EVENT("(GLuint program = %u, GLint location = %d, const GLchar *name = 0x%0.8p)", program,
1367           location, name);
1368 
1369     Context *context = GetValidGlobalContext();
1370     if (context)
1371     {
1372         if (!ValidateBindUniformLocationCHROMIUM(context, program, location, name))
1373         {
1374             return;
1375         }
1376 
1377         context->bindUniformLocation(program, location, name);
1378     }
1379 }
1380 
CoverageModulationCHROMIUM(GLenum components)1381 ANGLE_EXPORT void GL_APIENTRY CoverageModulationCHROMIUM(GLenum components)
1382 {
1383     EVENT("(GLenum components = %u)", components);
1384 
1385     Context *context = GetValidGlobalContext();
1386     if (context)
1387     {
1388         if (!ValidateCoverageModulationCHROMIUM(context, components))
1389         {
1390             return;
1391         }
1392         context->setCoverageModulation(components);
1393     }
1394 }
1395 
1396 // CHROMIUM_path_rendering
MatrixLoadfCHROMIUM(GLenum matrixMode,const GLfloat * matrix)1397 ANGLE_EXPORT void GL_APIENTRY MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat *matrix)
1398 {
1399     EVENT("(GLenum matrixMode = %u)", matrixMode);
1400 
1401     Context *context = GetValidGlobalContext();
1402     if (context)
1403     {
1404         if (!context->skipValidation() && !ValidateMatrix(context, matrixMode, matrix))
1405         {
1406             return;
1407         }
1408         context->loadPathRenderingMatrix(matrixMode, matrix);
1409     }
1410 }
1411 
MatrixLoadIdentityCHROMIUM(GLenum matrixMode)1412 ANGLE_EXPORT void GL_APIENTRY MatrixLoadIdentityCHROMIUM(GLenum matrixMode)
1413 {
1414     EVENT("(GLenum matrixMode = %u)", matrixMode);
1415 
1416     Context *context = GetValidGlobalContext();
1417     if (context)
1418     {
1419         if (!context->skipValidation() && !ValidateMatrixMode(context, matrixMode))
1420         {
1421             return;
1422         }
1423         context->loadPathRenderingIdentityMatrix(matrixMode);
1424     }
1425 }
1426 
GenPathsCHROMIUM(GLsizei range)1427 ANGLE_EXPORT GLuint GL_APIENTRY GenPathsCHROMIUM(GLsizei range)
1428 {
1429     EVENT("(GLsizei range = %d)", range);
1430 
1431     Context *context = GetValidGlobalContext();
1432     if (context)
1433     {
1434         if (!context->skipValidation() && !ValidateGenPaths(context, range))
1435         {
1436             return 0;
1437         }
1438         return context->createPaths(range);
1439     }
1440     return 0;
1441 }
1442 
DeletePathsCHROMIUM(GLuint first,GLsizei range)1443 ANGLE_EXPORT void GL_APIENTRY DeletePathsCHROMIUM(GLuint first, GLsizei range)
1444 {
1445     EVENT("(GLuint first = %u, GLsizei range = %d)", first, range);
1446 
1447     Context *context = GetValidGlobalContext();
1448     if (context)
1449     {
1450         if (!context->skipValidation() && !ValidateDeletePaths(context, first, range))
1451         {
1452             return;
1453         }
1454         context->deletePaths(first, range);
1455     }
1456 }
1457 
IsPathCHROMIUM(GLuint path)1458 ANGLE_EXPORT GLboolean GL_APIENTRY IsPathCHROMIUM(GLuint path)
1459 {
1460     EVENT("(GLuint path = %u)", path);
1461 
1462     Context *context = GetValidGlobalContext();
1463     if (context)
1464     {
1465         if (!context->skipValidation() && !ValidateIsPath(context))
1466         {
1467             return GL_FALSE;
1468         }
1469         return context->hasPathData(path);
1470     }
1471     return GL_FALSE;
1472 }
1473 
PathCommandsCHROMIUM(GLuint path,GLsizei numCommands,const GLubyte * commands,GLsizei numCoords,GLenum coordType,const void * coords)1474 ANGLE_EXPORT void GL_APIENTRY PathCommandsCHROMIUM(GLuint path,
1475                                                    GLsizei numCommands,
1476                                                    const GLubyte *commands,
1477                                                    GLsizei numCoords,
1478                                                    GLenum coordType,
1479                                                    const void *coords)
1480 {
1481     EVENT(
1482         "(GLuint path = %u, GLsizei numCommands = %d, commands = %p, "
1483         "GLsizei numCoords = %d, GLenum coordType = %u, void* coords = %p)",
1484         path, numCommands, commands, numCoords, coordType, coords);
1485 
1486     Context *context = GetValidGlobalContext();
1487     if (context)
1488     {
1489         if (!context->skipValidation())
1490         {
1491             if (!ValidatePathCommands(context, path, numCommands, commands, numCoords, coordType,
1492                                       coords))
1493             {
1494                 return;
1495             }
1496         }
1497         context->setPathCommands(path, numCommands, commands, numCoords, coordType, coords);
1498     }
1499 }
1500 
PathParameterfCHROMIUM(GLuint path,GLenum pname,GLfloat value)1501 ANGLE_EXPORT void GL_APIENTRY PathParameterfCHROMIUM(GLuint path, GLenum pname, GLfloat value)
1502 {
1503     EVENT("(GLuint path = %u, GLenum pname = %u, GLfloat value = %f)", path, pname, value);
1504 
1505     Context *context = GetValidGlobalContext();
1506     if (context)
1507     {
1508         if (!context->skipValidation() && !ValidateSetPathParameter(context, path, pname, value))
1509         {
1510             return;
1511         }
1512         context->setPathParameterf(path, pname, value);
1513     }
1514 }
1515 
PathParameteriCHROMIUM(GLuint path,GLenum pname,GLint value)1516 ANGLE_EXPORT void GL_APIENTRY PathParameteriCHROMIUM(GLuint path, GLenum pname, GLint value)
1517 {
1518     PathParameterfCHROMIUM(path, pname, static_cast<GLfloat>(value));
1519 }
1520 
GetPathParameterfCHROMIUM(GLuint path,GLenum pname,GLfloat * value)1521 ANGLE_EXPORT void GL_APIENTRY GetPathParameterfCHROMIUM(GLuint path, GLenum pname, GLfloat *value)
1522 {
1523     EVENT("(GLuint path = %u, GLenum pname = %u)", path, pname);
1524 
1525     Context *context = GetValidGlobalContext();
1526     if (context)
1527     {
1528         if (!context->skipValidation() && !ValidateGetPathParameter(context, path, pname, value))
1529         {
1530             return;
1531         }
1532         context->getPathParameterfv(path, pname, value);
1533     }
1534 }
1535 
GetPathParameteriCHROMIUM(GLuint path,GLenum pname,GLint * value)1536 ANGLE_EXPORT void GL_APIENTRY GetPathParameteriCHROMIUM(GLuint path, GLenum pname, GLint *value)
1537 {
1538     GLfloat val = 0.0f;
1539     GetPathParameterfCHROMIUM(path, pname, value != nullptr ? &val : nullptr);
1540     if (value)
1541         *value = static_cast<GLint>(val);
1542 }
1543 
PathStencilFuncCHROMIUM(GLenum func,GLint ref,GLuint mask)1544 ANGLE_EXPORT void GL_APIENTRY PathStencilFuncCHROMIUM(GLenum func, GLint ref, GLuint mask)
1545 {
1546     EVENT("(GLenum func = %u, GLint ref = %d, GLuint mask = %u)", func, ref, mask);
1547 
1548     Context *context = GetValidGlobalContext();
1549     if (context)
1550     {
1551         if (!context->skipValidation() && !ValidatePathStencilFunc(context, func, ref, mask))
1552         {
1553             return;
1554         }
1555         context->setPathStencilFunc(func, ref, mask);
1556     }
1557 }
1558 
StencilFillPathCHROMIUM(GLuint path,GLenum fillMode,GLuint mask)1559 ANGLE_EXPORT void GL_APIENTRY StencilFillPathCHROMIUM(GLuint path, GLenum fillMode, GLuint mask)
1560 {
1561     EVENT("(GLuint path = %u, GLenum fillMode = %u, GLuint mask = %u)", path, fillMode, mask);
1562 
1563     Context *context = GetValidGlobalContext();
1564     if (context)
1565     {
1566         if (!context->skipValidation() && !ValidateStencilFillPath(context, path, fillMode, mask))
1567         {
1568             return;
1569         }
1570         context->stencilFillPath(path, fillMode, mask);
1571     }
1572 }
1573 
StencilStrokePathCHROMIUM(GLuint path,GLint reference,GLuint mask)1574 ANGLE_EXPORT void GL_APIENTRY StencilStrokePathCHROMIUM(GLuint path, GLint reference, GLuint mask)
1575 {
1576     EVENT("(GLuint path = %u, GLint ference = %d, GLuint mask = %u)", path, reference, mask);
1577 
1578     Context *context = GetValidGlobalContext();
1579     if (context)
1580     {
1581         if (!context->skipValidation() &&
1582             !ValidateStencilStrokePath(context, path, reference, mask))
1583         {
1584             return;
1585         }
1586         context->stencilStrokePath(path, reference, mask);
1587     }
1588 }
1589 
CoverFillPathCHROMIUM(GLuint path,GLenum coverMode)1590 ANGLE_EXPORT void GL_APIENTRY CoverFillPathCHROMIUM(GLuint path, GLenum coverMode)
1591 {
1592     EVENT("(GLuint path = %u, GLenum coverMode = %u)", path, coverMode);
1593 
1594     Context *context = GetValidGlobalContext();
1595     if (context)
1596     {
1597         if (!context->skipValidation() && !ValidateCoverPath(context, path, coverMode))
1598         {
1599             return;
1600         }
1601         context->coverFillPath(path, coverMode);
1602     }
1603 }
1604 
CoverStrokePathCHROMIUM(GLuint path,GLenum coverMode)1605 ANGLE_EXPORT void GL_APIENTRY CoverStrokePathCHROMIUM(GLuint path, GLenum coverMode)
1606 {
1607     EVENT("(GLuint path = %u, GLenum coverMode = %u)", path, coverMode);
1608 
1609     Context *context = GetValidGlobalContext();
1610     if (context)
1611     {
1612         if (!context->skipValidation() && !ValidateCoverPath(context, path, coverMode))
1613         {
1614             return;
1615         }
1616         context->coverStrokePath(path, coverMode);
1617     }
1618 }
1619 
StencilThenCoverFillPathCHROMIUM(GLuint path,GLenum fillMode,GLuint mask,GLenum coverMode)1620 ANGLE_EXPORT void GL_APIENTRY StencilThenCoverFillPathCHROMIUM(GLuint path,
1621                                                                GLenum fillMode,
1622                                                                GLuint mask,
1623                                                                GLenum coverMode)
1624 {
1625     EVENT("(GLuint path = %u, GLenum fillMode = %u, GLuint mask = %u, GLenum coverMode = %u)", path,
1626           fillMode, mask, coverMode);
1627 
1628     Context *context = GetValidGlobalContext();
1629     if (context)
1630     {
1631         if (!context->skipValidation() &&
1632             !ValidateStencilThenCoverFillPath(context, path, fillMode, mask, coverMode))
1633         {
1634             return;
1635         }
1636         context->stencilThenCoverFillPath(path, fillMode, mask, coverMode);
1637     }
1638 }
1639 
StencilThenCoverStrokePathCHROMIUM(GLuint path,GLint reference,GLuint mask,GLenum coverMode)1640 ANGLE_EXPORT void GL_APIENTRY StencilThenCoverStrokePathCHROMIUM(GLuint path,
1641                                                                  GLint reference,
1642                                                                  GLuint mask,
1643                                                                  GLenum coverMode)
1644 {
1645     EVENT("(GLuint path = %u, GLint reference = %d, GLuint mask = %u, GLenum coverMode = %u)", path,
1646           reference, mask, coverMode);
1647 
1648     Context *context = GetValidGlobalContext();
1649     if (context)
1650     {
1651         if (!context->skipValidation() &&
1652             !ValidateStencilThenCoverStrokePath(context, path, reference, mask, coverMode))
1653         {
1654             return;
1655         }
1656         context->stencilThenCoverStrokePath(path, reference, mask, coverMode);
1657     }
1658 }
1659 
CoverFillPathInstancedCHROMIUM(GLsizei numPaths,GLenum pathNameType,const void * paths,GLuint pathBase,GLenum coverMode,GLenum transformType,const GLfloat * transformValues)1660 ANGLE_EXPORT void GL_APIENTRY CoverFillPathInstancedCHROMIUM(GLsizei numPaths,
1661                                                              GLenum pathNameType,
1662                                                              const void *paths,
1663                                                              GLuint pathBase,
1664                                                              GLenum coverMode,
1665                                                              GLenum transformType,
1666                                                              const GLfloat *transformValues)
1667 {
1668     EVENT(
1669         "(GLsizei numPaths = %d, GLenum pathNameType = %u, const void *paths = %p "
1670         "GLuint pathBase = %u, GLenum coverMode = %u, GLenum transformType = %u "
1671         "const GLfloat *transformValues = %p)",
1672         numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
1673 
1674     Context *context = GetValidGlobalContext();
1675     if (context)
1676     {
1677         if (!context->skipValidation() &&
1678             !ValidateCoverFillPathInstanced(context, numPaths, pathNameType, paths, pathBase,
1679                                             coverMode, transformType, transformValues))
1680         {
1681             return;
1682         }
1683         context->coverFillPathInstanced(numPaths, pathNameType, paths, pathBase, coverMode,
1684                                         transformType, transformValues);
1685     }
1686 }
1687 
CoverStrokePathInstancedCHROMIUM(GLsizei numPaths,GLenum pathNameType,const void * paths,GLuint pathBase,GLenum coverMode,GLenum transformType,const GLfloat * transformValues)1688 ANGLE_EXPORT void GL_APIENTRY CoverStrokePathInstancedCHROMIUM(GLsizei numPaths,
1689                                                                GLenum pathNameType,
1690                                                                const void *paths,
1691                                                                GLuint pathBase,
1692                                                                GLenum coverMode,
1693                                                                GLenum transformType,
1694                                                                const GLfloat *transformValues)
1695 {
1696     EVENT(
1697         "(GLsizei numPaths = %d, GLenum pathNameType = %u, const void *paths = %p "
1698         "GLuint pathBase = %u, GLenum coverMode = %u, GLenum transformType = %u "
1699         "const GLfloat *transformValues = %p)",
1700         numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
1701 
1702     Context *context = GetValidGlobalContext();
1703     if (context)
1704     {
1705         if (!context->skipValidation() &&
1706             !ValidateCoverStrokePathInstanced(context, numPaths, pathNameType, paths, pathBase,
1707                                               coverMode, transformType, transformValues))
1708         {
1709             return;
1710         }
1711         context->coverStrokePathInstanced(numPaths, pathNameType, paths, pathBase, coverMode,
1712                                           transformType, transformValues);
1713     }
1714 }
1715 
StencilStrokePathInstancedCHROMIUM(GLsizei numPaths,GLenum pathNameType,const void * paths,GLuint pathBase,GLint reference,GLuint mask,GLenum transformType,const GLfloat * transformValues)1716 ANGLE_EXPORT void GL_APIENTRY StencilStrokePathInstancedCHROMIUM(GLsizei numPaths,
1717                                                                  GLenum pathNameType,
1718                                                                  const void *paths,
1719                                                                  GLuint pathBase,
1720                                                                  GLint reference,
1721                                                                  GLuint mask,
1722                                                                  GLenum transformType,
1723                                                                  const GLfloat *transformValues)
1724 {
1725     EVENT(
1726         "(GLsizei numPaths = %u, GLenum pathNameType = %u, const void *paths = %p "
1727         "GLuint pathBase = %u, GLint reference = %d GLuint mask = %u GLenum transformType = %u "
1728         "const GLfloat *transformValues = %p)",
1729         numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
1730 
1731     Context *context = GetValidGlobalContext();
1732     if (context)
1733     {
1734         if (!context->skipValidation() &&
1735             !ValidateStencilStrokePathInstanced(context, numPaths, pathNameType, paths, pathBase,
1736                                                 reference, mask, transformType, transformValues))
1737         {
1738             return;
1739         }
1740         context->stencilStrokePathInstanced(numPaths, pathNameType, paths, pathBase, reference,
1741                                             mask, transformType, transformValues);
1742     }
1743 }
1744 
StencilFillPathInstancedCHROMIUM(GLsizei numPaths,GLenum pathNameType,const void * paths,GLuint pathBase,GLenum fillMode,GLuint mask,GLenum transformType,const GLfloat * transformValues)1745 ANGLE_EXPORT void GL_APIENTRY StencilFillPathInstancedCHROMIUM(GLsizei numPaths,
1746                                                                GLenum pathNameType,
1747                                                                const void *paths,
1748                                                                GLuint pathBase,
1749                                                                GLenum fillMode,
1750                                                                GLuint mask,
1751                                                                GLenum transformType,
1752                                                                const GLfloat *transformValues)
1753 {
1754     EVENT(
1755         "(GLsizei numPaths = %u, GLenum pathNameType = %u const void *paths = %p "
1756         "GLuint pathBase = %u, GLenum fillMode = %u, GLuint mask = %u, GLenum transformType = %u "
1757         "const GLfloat *transformValues = %p)",
1758         numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
1759 
1760     Context *context = GetValidGlobalContext();
1761     if (context)
1762     {
1763         if (!context->skipValidation() &&
1764             !ValidateStencilFillPathInstanced(context, numPaths, pathNameType, paths, pathBase,
1765                                               fillMode, mask, transformType, transformValues))
1766         {
1767             return;
1768         }
1769         context->stencilFillPathInstanced(numPaths, pathNameType, paths, pathBase, fillMode, mask,
1770                                           transformType, transformValues);
1771     }
1772 }
1773 
1774 ANGLE_EXPORT void GL_APIENTRY
StencilThenCoverFillPathInstancedCHROMIUM(GLsizei numPaths,GLenum pathNameType,const void * paths,GLuint pathBase,GLenum fillMode,GLuint mask,GLenum coverMode,GLenum transformType,const GLfloat * transformValues)1775 StencilThenCoverFillPathInstancedCHROMIUM(GLsizei numPaths,
1776                                           GLenum pathNameType,
1777                                           const void *paths,
1778                                           GLuint pathBase,
1779                                           GLenum fillMode,
1780                                           GLuint mask,
1781                                           GLenum coverMode,
1782                                           GLenum transformType,
1783                                           const GLfloat *transformValues)
1784 {
1785     EVENT(
1786         "(GLsizei numPaths = %u, GLenum pathNameType = %u const void *paths = %p "
1787         "GLuint pathBase = %u, GLenum coverMode = %u, GLuint mask = %u, GLenum transformType = %u "
1788         "const GLfloat *transformValues = %p)",
1789         numPaths, pathNameType, paths, pathBase, coverMode, mask, transformType, transformValues);
1790 
1791     Context *context = GetValidGlobalContext();
1792     if (context)
1793     {
1794         if (!context->skipValidation() &&
1795             !ValidateStencilThenCoverFillPathInstanced(context, numPaths, pathNameType, paths,
1796                                                        pathBase, fillMode, mask, coverMode,
1797                                                        transformType, transformValues))
1798         {
1799             return;
1800         }
1801         context->stencilThenCoverFillPathInstanced(numPaths, pathNameType, paths, pathBase,
1802                                                    fillMode, mask, coverMode, transformType,
1803                                                    transformValues);
1804     }
1805 }
1806 
1807 ANGLE_EXPORT void GL_APIENTRY
StencilThenCoverStrokePathInstancedCHROMIUM(GLsizei numPaths,GLenum pathNameType,const void * paths,GLuint pathBase,GLint reference,GLuint mask,GLenum coverMode,GLenum transformType,const GLfloat * transformValues)1808 StencilThenCoverStrokePathInstancedCHROMIUM(GLsizei numPaths,
1809                                             GLenum pathNameType,
1810                                             const void *paths,
1811                                             GLuint pathBase,
1812                                             GLint reference,
1813                                             GLuint mask,
1814                                             GLenum coverMode,
1815                                             GLenum transformType,
1816                                             const GLfloat *transformValues)
1817 {
1818     EVENT(
1819         "(GLsizei numPaths = %u, GLenum pathNameType = %u, const void *paths = %p "
1820         "GLuint pathBase = %u GLenum coverMode = %u GLint reference = %d GLuint mask = %u GLenum "
1821         "transformType = %u "
1822         "const GLfloat *transformValues = %p)",
1823         numPaths, pathNameType, paths, pathBase, coverMode, reference, mask, transformType,
1824         transformValues);
1825 
1826     Context *context = GetValidGlobalContext();
1827     if (context)
1828     {
1829         if (!context->skipValidation() &&
1830             !ValidateStencilThenCoverStrokePathInstanced(context, numPaths, pathNameType, paths,
1831                                                          pathBase, reference, mask, coverMode,
1832                                                          transformType, transformValues))
1833         {
1834             return;
1835         }
1836         context->stencilThenCoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
1837                                                      reference, mask, coverMode, transformType,
1838                                                      transformValues);
1839     }
1840 }
1841 
BindFragmentInputLocationCHROMIUM(GLuint program,GLint location,const GLchar * name)1842 ANGLE_EXPORT void GL_APIENTRY BindFragmentInputLocationCHROMIUM(GLuint program,
1843                                                                 GLint location,
1844                                                                 const GLchar *name)
1845 {
1846     EVENT("(GLuint program = %u, GLint location = %d, const GLchar *name = %p)", program, location,
1847           name);
1848 
1849     Context *context = GetValidGlobalContext();
1850     if (context)
1851     {
1852         if (!context->skipValidation() &&
1853             !ValidateBindFragmentInputLocation(context, program, location, name))
1854         {
1855             return;
1856         }
1857         context->bindFragmentInputLocation(program, location, name);
1858     }
1859 }
1860 
ProgramPathFragmentInputGenCHROMIUM(GLuint program,GLint location,GLenum genMode,GLint components,const GLfloat * coeffs)1861 ANGLE_EXPORT void GL_APIENTRY ProgramPathFragmentInputGenCHROMIUM(GLuint program,
1862                                                                   GLint location,
1863                                                                   GLenum genMode,
1864                                                                   GLint components,
1865                                                                   const GLfloat *coeffs)
1866 {
1867     EVENT(
1868         "(GLuint program = %u, GLint location %d, GLenum genMode = %u, GLint components = %d, "
1869         "const GLfloat * coeffs = %p)",
1870         program, location, genMode, components, coeffs);
1871 
1872     Context *context = GetValidGlobalContext();
1873     if (context)
1874     {
1875         if (!context->skipValidation() &&
1876             !ValidateProgramPathFragmentInputGen(context, program, location, genMode, components,
1877                                                  coeffs))
1878         {
1879             return;
1880         }
1881         context->programPathFragmentInputGen(program, location, genMode, components, coeffs);
1882     }
1883 }
1884 
CopyTextureCHROMIUM(GLuint sourceId,GLint sourceLevel,GLenum destTarget,GLuint destId,GLint destLevel,GLint internalFormat,GLenum destType,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)1885 ANGLE_EXPORT void GL_APIENTRY CopyTextureCHROMIUM(GLuint sourceId,
1886                                                   GLint sourceLevel,
1887                                                   GLenum destTarget,
1888                                                   GLuint destId,
1889                                                   GLint destLevel,
1890                                                   GLint internalFormat,
1891                                                   GLenum destType,
1892                                                   GLboolean unpackFlipY,
1893                                                   GLboolean unpackPremultiplyAlpha,
1894                                                   GLboolean unpackUnmultiplyAlpha)
1895 {
1896     EVENT(
1897         "(GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = 0x%X, GLuint destId = "
1898         "%u, GLint destLevel = %d, GLint internalFormat = 0x%X, GLenum destType = "
1899         "0x%X, GLboolean unpackFlipY = %u, GLboolean unpackPremultiplyAlpha = %u, GLboolean "
1900         "unpackUnmultiplyAlpha = %u)",
1901         sourceId, sourceLevel, destTarget, destId, destLevel, internalFormat, destType, unpackFlipY,
1902         unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
1903 
1904     Context *context = GetValidGlobalContext();
1905     if (context)
1906     {
1907         if (!context->skipValidation() &&
1908             !ValidateCopyTextureCHROMIUM(context, sourceId, sourceLevel, destTarget, destId,
1909                                          destLevel, internalFormat, destType, unpackFlipY,
1910                                          unpackPremultiplyAlpha, unpackUnmultiplyAlpha))
1911         {
1912             return;
1913         }
1914 
1915         context->copyTextureCHROMIUM(sourceId, sourceLevel, destTarget, destId, destLevel,
1916                                      internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
1917                                      unpackUnmultiplyAlpha);
1918     }
1919 }
1920 
CopySubTextureCHROMIUM(GLuint sourceId,GLint sourceLevel,GLenum destTarget,GLuint destId,GLint destLevel,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height,GLboolean unpackFlipY,GLboolean unpackPremultiplyAlpha,GLboolean unpackUnmultiplyAlpha)1921 ANGLE_EXPORT void GL_APIENTRY CopySubTextureCHROMIUM(GLuint sourceId,
1922                                                      GLint sourceLevel,
1923                                                      GLenum destTarget,
1924                                                      GLuint destId,
1925                                                      GLint destLevel,
1926                                                      GLint xoffset,
1927                                                      GLint yoffset,
1928                                                      GLint x,
1929                                                      GLint y,
1930                                                      GLsizei width,
1931                                                      GLsizei height,
1932                                                      GLboolean unpackFlipY,
1933                                                      GLboolean unpackPremultiplyAlpha,
1934                                                      GLboolean unpackUnmultiplyAlpha)
1935 {
1936     EVENT(
1937         "(GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = 0x%X, GLuint destId = "
1938         "%u, GLint destLevel = %d, GLint xoffset = "
1939         "%d, GLint yoffset = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = "
1940         "%d, GLboolean unpackPremultiplyAlpha = %u, GLboolean unpackUnmultiplyAlpha = %u)",
1941         sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, yoffset, x, y, width, height,
1942         unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
1943 
1944     Context *context = GetValidGlobalContext();
1945     if (context)
1946     {
1947         if (!context->skipValidation() &&
1948             !ValidateCopySubTextureCHROMIUM(
1949                 context, sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, yoffset, x,
1950                 y, width, height, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha))
1951         {
1952             return;
1953         }
1954 
1955         context->copySubTextureCHROMIUM(sourceId, sourceLevel, destTarget, destId, destLevel,
1956                                         xoffset, yoffset, x, y, width, height, unpackFlipY,
1957                                         unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
1958     }
1959 }
1960 
CompressedCopyTextureCHROMIUM(GLuint sourceId,GLuint destId)1961 ANGLE_EXPORT void GL_APIENTRY CompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId)
1962 {
1963     EVENT("(GLuint sourceId = %u, GLuint destId = %u)", sourceId, destId);
1964 
1965     Context *context = GetValidGlobalContext();
1966     if (context)
1967     {
1968         if (!context->skipValidation() &&
1969             !ValidateCompressedCopyTextureCHROMIUM(context, sourceId, destId))
1970         {
1971             return;
1972         }
1973 
1974         context->compressedCopyTextureCHROMIUM(sourceId, destId);
1975     }
1976 }
1977 
RequestExtensionANGLE(const GLchar * name)1978 ANGLE_EXPORT void GL_APIENTRY RequestExtensionANGLE(const GLchar *name)
1979 {
1980     EVENT("(const GLchar *name = %p)", name);
1981 
1982     Context *context = GetValidGlobalContext();
1983     if (context)
1984     {
1985         if (!context->skipValidation() && !ValidateRequestExtensionANGLE(context, name))
1986         {
1987             return;
1988         }
1989 
1990         context->requestExtension(name);
1991     }
1992 }
1993 
GetBooleanvRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLboolean * params)1994 ANGLE_EXPORT void GL_APIENTRY GetBooleanvRobustANGLE(GLenum pname,
1995                                                      GLsizei bufSize,
1996                                                      GLsizei *length,
1997                                                      GLboolean *params)
1998 {
1999     EVENT(
2000         "(GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLboolean* params "
2001         "= 0x%0.8p)",
2002         pname, bufSize, length, params);
2003 
2004     Context *context = GetValidGlobalContext();
2005     if (context)
2006     {
2007         GLenum nativeType;
2008         unsigned int numParams = 0;
2009         if (!ValidateRobustStateQuery(context, pname, bufSize, &nativeType, &numParams))
2010         {
2011             return;
2012         }
2013 
2014         context->getBooleanv(pname, params);
2015         SetRobustLengthParam(length, numParams);
2016     }
2017 }
2018 
GetBufferParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2019 ANGLE_EXPORT void GL_APIENTRY GetBufferParameterivRobustANGLE(GLenum target,
2020                                                               GLenum pname,
2021                                                               GLsizei bufSize,
2022                                                               GLsizei *length,
2023                                                               GLint *params)
2024 {
2025     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname,
2026           params);
2027 
2028     Context *context = GetValidGlobalContext();
2029     if (context)
2030     {
2031         BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
2032 
2033         GLsizei numParams = 0;
2034         if (!ValidateGetBufferParameterivRobustANGLE(context, targetPacked, pname, bufSize,
2035                                                      &numParams, params))
2036         {
2037             return;
2038         }
2039 
2040         Buffer *buffer = context->getGLState().getTargetBuffer(targetPacked);
2041         QueryBufferParameteriv(buffer, pname, params);
2042         SetRobustLengthParam(length, numParams);
2043     }
2044 }
2045 
GetFloatvRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)2046 ANGLE_EXPORT void GL_APIENTRY GetFloatvRobustANGLE(GLenum pname,
2047                                                    GLsizei bufSize,
2048                                                    GLsizei *length,
2049                                                    GLfloat *params)
2050 {
2051     EVENT(
2052         "(GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLfloat* params = "
2053         "0x%0.8p)",
2054         pname, bufSize, length, params);
2055 
2056     Context *context = GetValidGlobalContext();
2057     if (context)
2058     {
2059         GLenum nativeType;
2060         unsigned int numParams = 0;
2061         if (!ValidateRobustStateQuery(context, pname, bufSize, &nativeType, &numParams))
2062         {
2063             return;
2064         }
2065 
2066         context->getFloatv(pname, params);
2067         SetRobustLengthParam(length, numParams);
2068     }
2069 }
2070 
GetFramebufferAttachmentParameterivRobustANGLE(GLenum target,GLenum attachment,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2071 ANGLE_EXPORT void GL_APIENTRY GetFramebufferAttachmentParameterivRobustANGLE(GLenum target,
2072                                                                              GLenum attachment,
2073                                                                              GLenum pname,
2074                                                                              GLsizei bufSize,
2075                                                                              GLsizei *length,
2076                                                                              GLint *params)
2077 {
2078     EVENT(
2079         "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X,  GLsizei bufsize = "
2080         "%d, GLsizei* length = 0x%0.8p, GLint* params = 0x%0.8p)",
2081         target, attachment, pname, bufSize, length, params);
2082 
2083     Context *context = GetValidGlobalContext();
2084     if (context)
2085     {
2086         GLsizei numParams = 0;
2087         if (!ValidateGetFramebufferAttachmentParameterivRobustANGLE(context, target, attachment,
2088                                                                     pname, bufSize, &numParams))
2089         {
2090             return;
2091         }
2092 
2093         const Framebuffer *framebuffer = context->getGLState().getTargetFramebuffer(target);
2094         QueryFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
2095         SetRobustLengthParam(length, numParams);
2096     }
2097 }
2098 
GetIntegervRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLint * data)2099 ANGLE_EXPORT void GL_APIENTRY GetIntegervRobustANGLE(GLenum pname,
2100                                                      GLsizei bufSize,
2101                                                      GLsizei *length,
2102                                                      GLint *data)
2103 {
2104     EVENT(
2105         "(GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLint* params = "
2106         "0x%0.8p)",
2107         pname, bufSize, length, data);
2108 
2109     Context *context = GetValidGlobalContext();
2110     if (context)
2111     {
2112         GLenum nativeType;
2113         unsigned int numParams = 0;
2114         if (!ValidateRobustStateQuery(context, pname, bufSize, &nativeType, &numParams))
2115         {
2116             return;
2117         }
2118 
2119         context->getIntegerv(pname, data);
2120         SetRobustLengthParam(length, numParams);
2121     }
2122 }
2123 
GetProgramivRobustANGLE(GLuint program,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2124 ANGLE_EXPORT void GL_APIENTRY GetProgramivRobustANGLE(GLuint program,
2125                                                       GLenum pname,
2126                                                       GLsizei bufSize,
2127                                                       GLsizei *length,
2128                                                       GLint *params)
2129 {
2130     EVENT(
2131         "(GLuint program = %d, GLenum pname = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, "
2132         "GLint* params = 0x%0.8p)",
2133         program, pname, bufSize, length, params);
2134 
2135     Context *context = GetValidGlobalContext();
2136     if (context)
2137     {
2138         GLsizei numParams = 0;
2139         if (!ValidateGetProgramivRobustANGLE(context, program, pname, bufSize, &numParams))
2140         {
2141             return;
2142         }
2143 
2144         Program *programObject = context->getProgram(program);
2145         QueryProgramiv(context, programObject, pname, params);
2146         SetRobustLengthParam(length, numParams);
2147     }
2148 }
2149 
GetRenderbufferParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2150 ANGLE_EXPORT void GL_APIENTRY GetRenderbufferParameterivRobustANGLE(GLenum target,
2151                                                                     GLenum pname,
2152                                                                     GLsizei bufSize,
2153                                                                     GLsizei *length,
2154                                                                     GLint *params)
2155 {
2156     EVENT(
2157         "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
2158         "0x%0.8p, GLint* params = 0x%0.8p)",
2159         target, pname, bufSize, length, params);
2160 
2161     Context *context = GetValidGlobalContext();
2162     if (context)
2163     {
2164         GLsizei numParams = 0;
2165         if (!ValidateGetRenderbufferParameterivRobustANGLE(context, target, pname, bufSize,
2166                                                            &numParams, params))
2167         {
2168             return;
2169         }
2170 
2171         Renderbuffer *renderbuffer = context->getGLState().getCurrentRenderbuffer();
2172         QueryRenderbufferiv(context, renderbuffer, pname, params);
2173         SetRobustLengthParam(length, numParams);
2174     }
2175 }
2176 
2177 ANGLE_EXPORT void GL_APIENTRY
GetShaderivRobustANGLE(GLuint shader,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2178 GetShaderivRobustANGLE(GLuint shader, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *params)
2179 {
2180     EVENT(
2181         "(GLuint shader = %d, GLenum pname = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, "
2182         "GLint* params = 0x%0.8p)",
2183         shader, pname, bufSize, length, params);
2184 
2185     Context *context = GetValidGlobalContext();
2186     if (context)
2187     {
2188         GLsizei numParams = 0;
2189         if (!ValidateGetShaderivRobustANGLE(context, shader, pname, bufSize, &numParams, params))
2190         {
2191             return;
2192         }
2193 
2194         Shader *shaderObject = context->getShader(shader);
2195         QueryShaderiv(context, shaderObject, pname, params);
2196         SetRobustLengthParam(length, numParams);
2197     }
2198 }
2199 
GetTexParameterfvRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)2200 ANGLE_EXPORT void GL_APIENTRY GetTexParameterfvRobustANGLE(GLenum target,
2201                                                            GLenum pname,
2202                                                            GLsizei bufSize,
2203                                                            GLsizei *length,
2204                                                            GLfloat *params)
2205 {
2206     EVENT(
2207         "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
2208         "0x%0.8p, GLfloat* params = 0x%0.8p)",
2209         target, pname, bufSize, length, params);
2210 
2211     Context *context = GetValidGlobalContext();
2212     if (context)
2213     {
2214         GLsizei numParams = 0;
2215         if (!ValidateGetTexParameterfvRobustANGLE(context, target, pname, bufSize, &numParams,
2216                                                   params))
2217         {
2218             return;
2219         }
2220 
2221         Texture *texture = context->getTargetTexture(target);
2222         QueryTexParameterfv(texture, pname, params);
2223         SetRobustLengthParam(length, numParams);
2224     }
2225 }
2226 
GetTexParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2227 ANGLE_EXPORT void GL_APIENTRY GetTexParameterivRobustANGLE(GLenum target,
2228                                                            GLenum pname,
2229                                                            GLsizei bufSize,
2230                                                            GLsizei *length,
2231                                                            GLint *params)
2232 {
2233     EVENT(
2234         "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
2235         "0x%0.8p, GLfloat* params = 0x%0.8p)",
2236         target, pname, bufSize, length, params);
2237 
2238     Context *context = GetValidGlobalContext();
2239     if (context)
2240     {
2241         GLsizei numParams = 0;
2242         if (!ValidateGetTexParameterivRobustANGLE(context, target, pname, bufSize, &numParams,
2243                                                   params))
2244         {
2245             return;
2246         }
2247 
2248         Texture *texture = context->getTargetTexture(target);
2249         QueryTexParameteriv(texture, pname, params);
2250         SetRobustLengthParam(length, numParams);
2251     }
2252 }
2253 
GetUniformfvRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLfloat * params)2254 ANGLE_EXPORT void GL_APIENTRY GetUniformfvRobustANGLE(GLuint program,
2255                                                       GLint location,
2256                                                       GLsizei bufSize,
2257                                                       GLsizei *length,
2258                                                       GLfloat *params)
2259 {
2260     EVENT(
2261         "(GLuint program = %d, GLint location = %d, GLsizei bufsize = %d, GLsizei* length = "
2262         "0x%0.8p, GLfloat* params = 0x%0.8p)",
2263         program, location, bufSize, length, params);
2264 
2265     Context *context = GetValidGlobalContext();
2266     if (context)
2267     {
2268         GLsizei writeLength = 0;
2269         if (!ValidateGetUniformfvRobustANGLE(context, program, location, bufSize, &writeLength,
2270                                              params))
2271         {
2272             return;
2273         }
2274 
2275         Program *programObject = context->getProgram(program);
2276         ASSERT(programObject);
2277 
2278         programObject->getUniformfv(context, location, params);
2279         SetRobustLengthParam(length, writeLength);
2280     }
2281 }
2282 
GetUniformivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLint * params)2283 ANGLE_EXPORT void GL_APIENTRY GetUniformivRobustANGLE(GLuint program,
2284                                                       GLint location,
2285                                                       GLsizei bufSize,
2286                                                       GLsizei *length,
2287                                                       GLint *params)
2288 {
2289     EVENT(
2290         "(GLuint program = %d, GLint location = %d, GLsizei bufsize = %d, GLsizei* length = "
2291         "0x%0.8p, GLint* params = 0x%0.8p)",
2292         program, location, bufSize, length, params);
2293 
2294     Context *context = GetValidGlobalContext();
2295     if (context)
2296     {
2297         GLsizei writeLength = 0;
2298         if (!ValidateGetUniformivRobustANGLE(context, program, location, bufSize, &writeLength,
2299                                              params))
2300         {
2301             return;
2302         }
2303 
2304         Program *programObject = context->getProgram(program);
2305         ASSERT(programObject);
2306 
2307         programObject->getUniformiv(context, location, params);
2308         SetRobustLengthParam(length, writeLength);
2309     }
2310 }
2311 
GetVertexAttribfvRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)2312 ANGLE_EXPORT void GL_APIENTRY GetVertexAttribfvRobustANGLE(GLuint index,
2313                                                            GLenum pname,
2314                                                            GLsizei bufSize,
2315                                                            GLsizei *length,
2316                                                            GLfloat *params)
2317 {
2318     EVENT(
2319         "(GLuint index = %d, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, "
2320         "GLfloat* params = 0x%0.8p)",
2321         index, pname, bufSize, length, params);
2322 
2323     Context *context = GetValidGlobalContext();
2324     if (context)
2325     {
2326         GLsizei writeLength = 0;
2327         if (!ValidateGetVertexAttribfvRobustANGLE(context, index, pname, bufSize, &writeLength,
2328                                                   params))
2329         {
2330             return;
2331         }
2332 
2333         context->getVertexAttribfv(index, pname, params);
2334         SetRobustLengthParam(length, writeLength);
2335     }
2336 }
2337 
GetVertexAttribivRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2338 ANGLE_EXPORT void GL_APIENTRY GetVertexAttribivRobustANGLE(GLuint index,
2339                                                            GLenum pname,
2340                                                            GLsizei bufSize,
2341                                                            GLsizei *length,
2342                                                            GLint *params)
2343 {
2344     EVENT(
2345         "(GLuint index = %d, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, "
2346         "GLint* params = 0x%0.8p)",
2347         index, pname, bufSize, length, params);
2348 
2349     Context *context = GetValidGlobalContext();
2350     if (context)
2351     {
2352         GLsizei writeLength = 0;
2353         if (!ValidateGetVertexAttribivRobustANGLE(context, index, pname, bufSize, &writeLength,
2354                                                   params))
2355         {
2356             return;
2357         }
2358 
2359         context->getVertexAttribiv(index, pname, params);
2360         SetRobustLengthParam(length, writeLength);
2361     }
2362 }
2363 
GetVertexAttribPointervRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,void ** pointer)2364 ANGLE_EXPORT void GL_APIENTRY GetVertexAttribPointervRobustANGLE(GLuint index,
2365                                                                  GLenum pname,
2366                                                                  GLsizei bufSize,
2367                                                                  GLsizei *length,
2368                                                                  void **pointer)
2369 {
2370     EVENT(
2371         "(GLuint index = %d, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, "
2372         "void** pointer = 0x%0.8p)",
2373         index, pname, bufSize, length, pointer);
2374 
2375     Context *context = GetValidGlobalContext();
2376     if (context)
2377     {
2378         GLsizei writeLength = 0;
2379         if (!ValidateGetVertexAttribPointervRobustANGLE(context, index, pname, bufSize,
2380                                                         &writeLength, pointer))
2381         {
2382             return;
2383         }
2384 
2385         context->getVertexAttribPointerv(index, pname, pointer);
2386         SetRobustLengthParam(length, writeLength);
2387     }
2388 }
2389 
ReadPixelsRobustANGLE(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLsizei * length,GLsizei * columns,GLsizei * rows,void * pixels)2390 ANGLE_EXPORT void GL_APIENTRY ReadPixelsRobustANGLE(GLint x,
2391                                                     GLint y,
2392                                                     GLsizei width,
2393                                                     GLsizei height,
2394                                                     GLenum format,
2395                                                     GLenum type,
2396                                                     GLsizei bufSize,
2397                                                     GLsizei *length,
2398                                                     GLsizei *columns,
2399                                                     GLsizei *rows,
2400                                                     void *pixels)
2401 {
2402     EVENT(
2403         "(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
2404         "GLenum format = 0x%X, GLenum type = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
2405         "0x%0.8p, GLsizei* columns = 0x%0.8p, GLsizei* rows = 0x%0.8p, void* pixels = 0x%0.8p)",
2406         x, y, width, height, format, type, bufSize, length, columns, rows, pixels);
2407 
2408     Context *context = GetValidGlobalContext();
2409     if (context)
2410     {
2411         GLsizei writeLength  = 0;
2412         GLsizei writeColumns = 0;
2413         GLsizei writeRows    = 0;
2414         if (!ValidateReadPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize,
2415                                            &writeLength, &writeColumns, &writeRows, pixels))
2416         {
2417             return;
2418         }
2419 
2420         context->readPixels(x, y, width, height, format, type, pixels);
2421 
2422         SetRobustLengthParam(length, writeLength);
2423         SetRobustLengthParam(columns, writeColumns);
2424         SetRobustLengthParam(rows, writeRows);
2425     }
2426 }
2427 
TexImage2DRobustANGLE(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)2428 ANGLE_EXPORT void GL_APIENTRY TexImage2DRobustANGLE(GLenum target,
2429                                                     GLint level,
2430                                                     GLint internalformat,
2431                                                     GLsizei width,
2432                                                     GLsizei height,
2433                                                     GLint border,
2434                                                     GLenum format,
2435                                                     GLenum type,
2436                                                     GLsizei bufSize,
2437                                                     const void *pixels)
2438 {
2439     EVENT(
2440         "(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
2441         "GLsizei height = %d, GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X, GLsizei "
2442         "bufSize = %d, const void* pixels = 0x%0.8p)",
2443         target, level, internalformat, width, height, border, format, type, bufSize, pixels);
2444 
2445     Context *context = GetValidGlobalContext();
2446     if (context)
2447     {
2448         if (!ValidateTexImage2DRobust(context, target, level, internalformat, width, height, border,
2449                                       format, type, bufSize, pixels))
2450         {
2451             return;
2452         }
2453 
2454         context->texImage2D(target, level, internalformat, width, height, border, format, type,
2455                             pixels);
2456     }
2457 }
2458 
TexParameterfvRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLfloat * params)2459 ANGLE_EXPORT void GL_APIENTRY TexParameterfvRobustANGLE(GLenum target,
2460                                                         GLenum pname,
2461                                                         GLsizei bufSize,
2462                                                         const GLfloat *params)
2463 {
2464     EVENT(
2465         "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufsize = %d, GLfloat* params = "
2466         "0x%0.8p)",
2467         target, pname, bufSize, params);
2468 
2469     Context *context = GetValidGlobalContext();
2470     if (context)
2471     {
2472         if (!ValidateTexParameterfvRobustANGLE(context, target, pname, bufSize, params))
2473         {
2474             return;
2475         }
2476 
2477         Texture *texture = context->getTargetTexture(target);
2478         SetTexParameterfv(context, texture, pname, params);
2479     }
2480 }
2481 
TexParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLint * params)2482 ANGLE_EXPORT void GL_APIENTRY TexParameterivRobustANGLE(GLenum target,
2483                                                         GLenum pname,
2484                                                         GLsizei bufSize,
2485                                                         const GLint *params)
2486 {
2487     EVENT(
2488         "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufsize = %d, GLfloat* params = "
2489         "0x%0.8p)",
2490         target, pname, bufSize, params);
2491 
2492     Context *context = GetValidGlobalContext();
2493     if (context)
2494     {
2495         if (!ValidateTexParameterivRobustANGLE(context, target, pname, bufSize, params))
2496         {
2497             return;
2498         }
2499 
2500         Texture *texture = context->getTargetTexture(target);
2501         SetTexParameteriv(context, texture, pname, params);
2502     }
2503 }
2504 
TexSubImage2DRobustANGLE(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)2505 ANGLE_EXPORT void GL_APIENTRY TexSubImage2DRobustANGLE(GLenum target,
2506                                                        GLint level,
2507                                                        GLint xoffset,
2508                                                        GLint yoffset,
2509                                                        GLsizei width,
2510                                                        GLsizei height,
2511                                                        GLenum format,
2512                                                        GLenum type,
2513                                                        GLsizei bufSize,
2514                                                        const void *pixels)
2515 {
2516     EVENT(
2517         "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
2518         "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, GLenum type = 0x%X, "
2519         "GLsizei bufsize = %d, const void* pixels = 0x%0.8p)",
2520         target, level, xoffset, yoffset, width, height, format, type, bufSize, pixels);
2521 
2522     Context *context = GetValidGlobalContext();
2523     if (context)
2524     {
2525         if (!ValidateTexSubImage2DRobustANGLE(context, target, level, xoffset, yoffset, width,
2526                                               height, format, type, bufSize, pixels))
2527         {
2528             return;
2529         }
2530 
2531         context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
2532                                pixels);
2533     }
2534 }
2535 
TexImage3DRobustANGLE(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)2536 ANGLE_EXPORT void GL_APIENTRY TexImage3DRobustANGLE(GLenum target,
2537                                                     GLint level,
2538                                                     GLint internalformat,
2539                                                     GLsizei width,
2540                                                     GLsizei height,
2541                                                     GLsizei depth,
2542                                                     GLint border,
2543                                                     GLenum format,
2544                                                     GLenum type,
2545                                                     GLsizei bufSize,
2546                                                     const void *pixels)
2547 {
2548     EVENT(
2549         "(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
2550         "GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = 0x%X, "
2551         "GLenum type = 0x%X, GLsizei bufsize = %d, const void* pixels = 0x%0.8p)",
2552         target, level, internalformat, width, height, depth, border, format, type, bufSize, pixels);
2553 
2554     Context *context = GetValidGlobalContext();
2555     if (context)
2556     {
2557         if (!ValidateTexImage3DRobustANGLE(context, target, level, internalformat, width, height,
2558                                            depth, border, format, type, bufSize, pixels))
2559         {
2560             return;
2561         }
2562 
2563         context->texImage3D(target, level, internalformat, width, height, depth, border, format,
2564                             type, pixels);
2565     }
2566 }
2567 
TexSubImage3DRobustANGLE(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,GLsizei bufSize,const void * pixels)2568 ANGLE_EXPORT void GL_APIENTRY TexSubImage3DRobustANGLE(GLenum target,
2569                                                        GLint level,
2570                                                        GLint xoffset,
2571                                                        GLint yoffset,
2572                                                        GLint zoffset,
2573                                                        GLsizei width,
2574                                                        GLsizei height,
2575                                                        GLsizei depth,
2576                                                        GLenum format,
2577                                                        GLenum type,
2578                                                        GLsizei bufSize,
2579                                                        const void *pixels)
2580 {
2581     EVENT(
2582         "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
2583         "GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
2584         "GLenum format = 0x%X, GLenum type = 0x%X, GLsizei bufsize = %d, const void* pixels = "
2585         "0x%0.8p)",
2586         target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize,
2587         pixels);
2588 
2589     Context *context = GetValidGlobalContext();
2590     if (context)
2591     {
2592         if (!ValidateTexSubImage3DRobustANGLE(context, target, level, xoffset, yoffset, zoffset,
2593                                               width, height, depth, format, type, bufSize, pixels))
2594         {
2595             return;
2596         }
2597 
2598         context->texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth,
2599                                format, type, pixels);
2600     }
2601 }
2602 
CompressedTexImage2DRobustANGLE(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)2603 void GL_APIENTRY CompressedTexImage2DRobustANGLE(GLenum target,
2604                                                  GLint level,
2605                                                  GLenum internalformat,
2606                                                  GLsizei width,
2607                                                  GLsizei height,
2608                                                  GLint border,
2609                                                  GLsizei imageSize,
2610                                                  GLsizei dataSize,
2611                                                  const GLvoid *data)
2612 {
2613     EVENT(
2614         "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
2615         "%d, "
2616         "GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, GLsizei dataSize = %d, "
2617         "const GLvoid* data = 0x%0.8p)",
2618         target, level, internalformat, width, height, border, imageSize, dataSize, data);
2619 
2620     Context *context = GetValidGlobalContext();
2621     if (context)
2622     {
2623         if (!context->skipValidation() &&
2624             !ValidateCompressedTexImage2DRobustANGLE(context, target, level, internalformat, width,
2625                                                      height, border, imageSize, dataSize, data))
2626         {
2627             return;
2628         }
2629 
2630         context->compressedTexImage2D(target, level, internalformat, width, height, border,
2631                                       imageSize, data);
2632     }
2633 }
2634 
CompressedTexSubImage2DRobustANGLE(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)2635 void GL_APIENTRY CompressedTexSubImage2DRobustANGLE(GLenum target,
2636                                                     GLint level,
2637                                                     GLint xoffset,
2638                                                     GLint yoffset,
2639                                                     GLsizei width,
2640                                                     GLsizei height,
2641                                                     GLenum format,
2642                                                     GLsizei imageSize,
2643                                                     GLsizei dataSize,
2644                                                     const GLvoid *data)
2645 {
2646     EVENT(
2647         "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
2648         "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, "
2649         "GLsizei imageSize = %d, GLsizei dataSize = %d, const GLvoid* data = 0x%0.8p)",
2650         target, level, xoffset, yoffset, width, height, format, imageSize, dataSize, data);
2651 
2652     Context *context = GetValidGlobalContext();
2653     if (context)
2654     {
2655         if (!context->skipValidation() && !ValidateCompressedTexSubImage2DRobustANGLE(
2656                                               context, target, level, xoffset, yoffset, width,
2657                                               height, format, imageSize, dataSize, data))
2658         {
2659             return;
2660         }
2661 
2662         context->compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format,
2663                                          imageSize, data);
2664     }
2665 }
2666 
CompressedTexImage3DRobustANGLE(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)2667 void GL_APIENTRY CompressedTexImage3DRobustANGLE(GLenum target,
2668                                                  GLint level,
2669                                                  GLenum internalformat,
2670                                                  GLsizei width,
2671                                                  GLsizei height,
2672                                                  GLsizei depth,
2673                                                  GLint border,
2674                                                  GLsizei imageSize,
2675                                                  GLsizei dataSize,
2676                                                  const GLvoid *data)
2677 {
2678     EVENT(
2679         "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
2680         "%d, "
2681         "GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei imageSize = %d, "
2682         "GLsizei dataSize = %d, const GLvoid* data = 0x%0.8p)",
2683         target, level, internalformat, width, height, depth, border, imageSize, dataSize, data);
2684 
2685     Context *context = GetValidGlobalContext();
2686     if (context)
2687     {
2688         if (!context->skipValidation() && !ValidateCompressedTexImage3DRobustANGLE(
2689                                               context, target, level, internalformat, width, height,
2690                                               depth, border, imageSize, dataSize, data))
2691         {
2692             return;
2693         }
2694 
2695         context->compressedTexImage3D(target, level, internalformat, width, height, depth, border,
2696                                       imageSize, data);
2697     }
2698 }
2699 
CompressedTexSubImage3DRobustANGLE(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,GLsizei dataSize,const GLvoid * data)2700 void GL_APIENTRY CompressedTexSubImage3DRobustANGLE(GLenum target,
2701                                                     GLint level,
2702                                                     GLint xoffset,
2703                                                     GLint yoffset,
2704                                                     GLint zoffset,
2705                                                     GLsizei width,
2706                                                     GLsizei height,
2707                                                     GLsizei depth,
2708                                                     GLenum format,
2709                                                     GLsizei imageSize,
2710                                                     GLsizei dataSize,
2711                                                     const GLvoid *data)
2712 {
2713     EVENT(
2714         "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
2715         "GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
2716         "GLenum format = 0x%X, GLsizei imageSize = %d, GLsizei dataSize = %d, const GLvoid* data = "
2717         "0x%0.8p)",
2718         target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, dataSize,
2719         data);
2720 
2721     Context *context = GetValidGlobalContext();
2722     if (context)
2723     {
2724         if (!context->skipValidation() &&
2725             !ValidateCompressedTexSubImage3DRobustANGLE(context, target, level, xoffset, yoffset,
2726                                                         zoffset, width, height, depth, format,
2727                                                         imageSize, dataSize, data))
2728         {
2729             return;
2730         }
2731 
2732         context->compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height,
2733                                          depth, format, imageSize, data);
2734     }
2735 }
2736 
2737 ANGLE_EXPORT void GL_APIENTRY
GetQueryivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2738 GetQueryivRobustANGLE(GLenum target, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *params)
2739 {
2740     EVENT(
2741         "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
2742         "0x%0.8p, GLint* params = 0x%0.8p)",
2743         target, pname, bufSize, length, params);
2744 
2745     Context *context = GetValidGlobalContext();
2746     if (context)
2747     {
2748         GLsizei numParams = 0;
2749         if (!ValidateGetQueryivRobustANGLE(context, target, pname, bufSize, &numParams, params))
2750         {
2751             return;
2752         }
2753 
2754         context->getQueryiv(target, pname, params);
2755         SetRobustLengthParam(length, numParams);
2756     }
2757 }
2758 
GetQueryObjectuivRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2759 ANGLE_EXPORT void GL_APIENTRY GetQueryObjectuivRobustANGLE(GLuint id,
2760                                                            GLenum pname,
2761                                                            GLsizei bufSize,
2762                                                            GLsizei *length,
2763                                                            GLuint *params)
2764 {
2765     EVENT(
2766         "(GLuint id = %u, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, "
2767         "GLint* params = 0x%0.8p)",
2768         id, pname, bufSize, length, params);
2769 
2770     Context *context = GetValidGlobalContext();
2771     if (context)
2772     {
2773         GLsizei numParams = 0;
2774         if (!ValidateGetQueryObjectuivRobustANGLE(context, id, pname, bufSize, &numParams, params))
2775         {
2776             return;
2777         }
2778 
2779         context->getQueryObjectuiv(id, pname, params);
2780         SetRobustLengthParam(length, numParams);
2781     }
2782 }
2783 
GetBufferPointervRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)2784 ANGLE_EXPORT void GL_APIENTRY GetBufferPointervRobustANGLE(GLenum target,
2785                                                            GLenum pname,
2786                                                            GLsizei bufSize,
2787                                                            GLsizei *length,
2788                                                            void **params)
2789 {
2790     EVENT(
2791         "(GLenum target = 0x%X, GLenum pname = 0x%X,  GLsizei bufsize = %d, GLsizei* length = "
2792         "0x%0.8p, void** params = 0x%0.8p)",
2793         target, pname, bufSize, length, params);
2794 
2795     Context *context = GetValidGlobalContext();
2796     if (context)
2797     {
2798         BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
2799 
2800         GLsizei numParams = 0;
2801         if (!ValidateGetBufferPointervRobustANGLE(context, targetPacked, pname, bufSize, &numParams,
2802                                                   params))
2803         {
2804             return;
2805         }
2806 
2807         context->getBufferPointerv(targetPacked, pname, params);
2808         SetRobustLengthParam(length, numParams);
2809     }
2810 }
2811 
2812 ANGLE_EXPORT void GL_APIENTRY
GetIntegeri_vRobustANGLE(GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint * data)2813 GetIntegeri_vRobustANGLE(GLenum target, GLuint index, GLsizei bufSize, GLsizei *length, GLint *data)
2814 {
2815     EVENT(
2816         "(GLenum target = 0x%X, GLuint index = %u, GLsizei bufsize = %d, GLsizei* length = "
2817         "0x%0.8p, GLint* data = 0x%0.8p)",
2818         target, index, bufSize, length, data);
2819 
2820     Context *context = GetValidGlobalContext();
2821     if (context)
2822     {
2823         GLsizei numParams = 0;
2824         if (!ValidateGetIntegeri_vRobustANGLE(context, target, index, bufSize, &numParams, data))
2825         {
2826             return;
2827         }
2828 
2829         context->getIntegeri_v(target, index, data);
2830         SetRobustLengthParam(length, numParams);
2831     }
2832 }
2833 
GetInternalformativRobustANGLE(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2834 ANGLE_EXPORT void GL_APIENTRY GetInternalformativRobustANGLE(GLenum target,
2835                                                              GLenum internalformat,
2836                                                              GLenum pname,
2837                                                              GLsizei bufSize,
2838                                                              GLsizei *length,
2839                                                              GLint *params)
2840 {
2841     EVENT(
2842         "(GLenum target = 0x%X, GLenum internalformat = 0x%X, GLenum pname = 0x%X, GLsizei bufSize "
2843         "= %d, GLsizei* length = 0x%0.8p, GLint* params = 0x%0.8p)",
2844         target, internalformat, pname, bufSize, length, params);
2845 
2846     Context *context = GetValidGlobalContext();
2847     if (context)
2848     {
2849         GLsizei numParams = 0;
2850         if (!ValidateGetInternalFormativRobustANGLE(context, target, internalformat, pname, bufSize,
2851                                                     &numParams, params))
2852         {
2853             return;
2854         }
2855 
2856         const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat);
2857         QueryInternalFormativ(formatCaps, pname, bufSize, params);
2858         SetRobustLengthParam(length, numParams);
2859     }
2860 }
2861 
GetVertexAttribIivRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2862 ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIivRobustANGLE(GLuint index,
2863                                                             GLenum pname,
2864                                                             GLsizei bufSize,
2865                                                             GLsizei *length,
2866                                                             GLint *params)
2867 {
2868     EVENT(
2869         "(GLuint index = %u, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, "
2870         "GLint* params = 0x%0.8p)",
2871         index, pname, bufSize, length, params);
2872 
2873     Context *context = GetValidGlobalContext();
2874     if (context)
2875     {
2876         GLsizei writeLength = 0;
2877         if (!ValidateGetVertexAttribIivRobustANGLE(context, index, pname, bufSize, &writeLength,
2878                                                    params))
2879         {
2880             return;
2881         }
2882 
2883         context->getVertexAttribIiv(index, pname, params);
2884         SetRobustLengthParam(length, writeLength);
2885     }
2886 }
2887 
GetVertexAttribIuivRobustANGLE(GLuint index,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)2888 ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIuivRobustANGLE(GLuint index,
2889                                                              GLenum pname,
2890                                                              GLsizei bufSize,
2891                                                              GLsizei *length,
2892                                                              GLuint *params)
2893 {
2894     EVENT(
2895         "(GLuint index = %u, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, "
2896         "GLuint* params = 0x%0.8p)",
2897         index, pname, bufSize, length, params);
2898 
2899     Context *context = GetValidGlobalContext();
2900     if (context)
2901     {
2902         GLsizei writeLength = 0;
2903         if (!ValidateGetVertexAttribIuivRobustANGLE(context, index, pname, bufSize, &writeLength,
2904                                                     params))
2905         {
2906             return;
2907         }
2908 
2909         context->getVertexAttribIuiv(index, pname, params);
2910         SetRobustLengthParam(length, writeLength);
2911     }
2912 }
2913 
GetUniformuivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLuint * params)2914 ANGLE_EXPORT void GL_APIENTRY GetUniformuivRobustANGLE(GLuint program,
2915                                                        GLint location,
2916                                                        GLsizei bufSize,
2917                                                        GLsizei *length,
2918                                                        GLuint *params)
2919 {
2920     EVENT(
2921         "(GLuint program = %u, GLint location = %d, GLsizei bufsize = %d, GLsizei* length = "
2922         "0x%0.8p, GLuint* params = 0x%0.8p)",
2923         program, location, bufSize, length, params);
2924 
2925     Context *context = GetValidGlobalContext();
2926     if (context)
2927     {
2928         GLsizei writeLength = 0;
2929         if (!ValidateGetUniformuivRobustANGLE(context, program, location, bufSize, &writeLength,
2930                                               params))
2931         {
2932             return;
2933         }
2934 
2935         Program *programObject = context->getProgram(program);
2936         ASSERT(programObject);
2937 
2938         programObject->getUniformuiv(context, location, params);
2939         SetRobustLengthParam(length, writeLength);
2940     }
2941 }
2942 
GetActiveUniformBlockivRobustANGLE(GLuint program,GLuint uniformBlockIndex,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)2943 ANGLE_EXPORT void GL_APIENTRY GetActiveUniformBlockivRobustANGLE(GLuint program,
2944                                                                  GLuint uniformBlockIndex,
2945                                                                  GLenum pname,
2946                                                                  GLsizei bufSize,
2947                                                                  GLsizei *length,
2948                                                                  GLint *params)
2949 {
2950     EVENT(
2951         "(GLuint program = %u, GLuint uniformBlockIndex = %u, GLenum pname = 0x%X, GLsizei bufsize "
2952         "= %d, GLsizei* length = 0x%0.8p, GLint* params = 0x%0.8p)",
2953         program, uniformBlockIndex, pname, bufSize, length, params);
2954 
2955     Context *context = GetValidGlobalContext();
2956     if (context)
2957     {
2958         GLsizei writeLength = 0;
2959         if (!ValidateGetActiveUniformBlockivRobustANGLE(context, program, uniformBlockIndex, pname,
2960                                                         bufSize, &writeLength, params))
2961         {
2962             return;
2963         }
2964 
2965         const Program *programObject = context->getProgram(program);
2966         QueryActiveUniformBlockiv(programObject, uniformBlockIndex, pname, params);
2967         SetRobustLengthParam(length, writeLength);
2968     }
2969 }
2970 
GetInteger64vRobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * data)2971 ANGLE_EXPORT void GL_APIENTRY GetInteger64vRobustANGLE(GLenum pname,
2972                                                        GLsizei bufSize,
2973                                                        GLsizei *length,
2974                                                        GLint64 *data)
2975 {
2976     EVENT(
2977         "(GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLint64* params = "
2978         "0x%0.8p)",
2979         pname, bufSize, length, data);
2980 
2981     Context *context = GetValidGlobalContext();
2982     if (context)
2983     {
2984         GLenum nativeType;
2985         unsigned int numParams = 0;
2986         if (!ValidateRobustStateQuery(context, pname, bufSize, &nativeType, &numParams))
2987         {
2988             return;
2989         }
2990 
2991         if (nativeType == GL_INT_64_ANGLEX)
2992         {
2993             context->getInteger64v(pname, data);
2994         }
2995         else
2996         {
2997             CastStateValues(context, nativeType, pname, numParams, data);
2998         }
2999         SetRobustLengthParam(length, numParams);
3000     }
3001 }
3002 
GetInteger64i_vRobustANGLE(GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLint64 * data)3003 ANGLE_EXPORT void GL_APIENTRY GetInteger64i_vRobustANGLE(GLenum target,
3004                                                          GLuint index,
3005                                                          GLsizei bufSize,
3006                                                          GLsizei *length,
3007                                                          GLint64 *data)
3008 {
3009     EVENT(
3010         "(GLenum target = 0x%X, GLuint index = %u, GLsizei bufsize = %d, GLsizei* length = "
3011         "0x%0.8p, GLint64* data = 0x%0.8p)",
3012         target, index, bufSize, length, data);
3013 
3014     Context *context = GetValidGlobalContext();
3015     if (context)
3016     {
3017         GLsizei numParams = 0;
3018         if (!ValidateGetInteger64i_vRobustANGLE(context, target, index, bufSize, &numParams, data))
3019         {
3020             return;
3021         }
3022 
3023         context->getInteger64i_v(target, index, data);
3024         SetRobustLengthParam(length, numParams);
3025     }
3026 }
3027 
GetBufferParameteri64vRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)3028 ANGLE_EXPORT void GL_APIENTRY GetBufferParameteri64vRobustANGLE(GLenum target,
3029                                                                 GLenum pname,
3030                                                                 GLsizei bufSize,
3031                                                                 GLsizei *length,
3032                                                                 GLint64 *params)
3033 {
3034     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint64* params = 0x%0.8p)", target, pname,
3035           bufSize, length, params);
3036 
3037     Context *context = GetValidGlobalContext();
3038     if (context)
3039     {
3040         BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
3041 
3042         GLsizei numParams = 0;
3043         if (!ValidateGetBufferParameteri64vRobustANGLE(context, targetPacked, pname, bufSize,
3044                                                        &numParams, params))
3045         {
3046             return;
3047         }
3048 
3049         Buffer *buffer = context->getGLState().getTargetBuffer(targetPacked);
3050         QueryBufferParameteri64v(buffer, pname, params);
3051         SetRobustLengthParam(length, numParams);
3052     }
3053 }
3054 
SamplerParameterivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLint * param)3055 ANGLE_EXPORT void GL_APIENTRY SamplerParameterivRobustANGLE(GLuint sampler,
3056                                                             GLenum pname,
3057                                                             GLsizei bufSize,
3058                                                             const GLint *param)
3059 {
3060     EVENT(
3061         "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufsize = %d, const GLint* params = "
3062         "0x%0.8p)",
3063         sampler, pname, bufSize, param);
3064 
3065     Context *context = GetValidGlobalContext();
3066     if (context)
3067     {
3068         if (!ValidateSamplerParameterivRobustANGLE(context, sampler, pname, bufSize, param))
3069         {
3070             return;
3071         }
3072 
3073         context->samplerParameteriv(sampler, pname, param);
3074     }
3075 }
3076 
SamplerParameterfvRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLfloat * param)3077 ANGLE_EXPORT void GL_APIENTRY SamplerParameterfvRobustANGLE(GLuint sampler,
3078                                                             GLenum pname,
3079                                                             GLsizei bufSize,
3080                                                             const GLfloat *param)
3081 {
3082     EVENT(
3083         "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufsize = %d, const GLfloat* params = "
3084         "0x%0.8p)",
3085         sampler, pname, bufSize, param);
3086 
3087     Context *context = GetValidGlobalContext();
3088     if (context)
3089     {
3090         if (!ValidateSamplerParameterfvRobustANGLE(context, sampler, pname, bufSize, param))
3091         {
3092             return;
3093         }
3094 
3095         context->samplerParameterfv(sampler, pname, param);
3096     }
3097 }
3098 
GetSamplerParameterivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3099 ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterivRobustANGLE(GLuint sampler,
3100                                                                GLenum pname,
3101                                                                GLsizei bufSize,
3102                                                                GLsizei *length,
3103                                                                GLint *params)
3104 {
3105     EVENT(
3106         "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
3107         "0x%0.8p, GLint* params = 0x%0.8p)",
3108         sampler, pname, bufSize, length, params);
3109 
3110     Context *context = GetValidGlobalContext();
3111     if (context)
3112     {
3113         GLsizei numParams = 0;
3114         if (!ValidateGetSamplerParameterivRobustANGLE(context, sampler, pname, bufSize, &numParams,
3115                                                       params))
3116         {
3117             return;
3118         }
3119 
3120         context->getSamplerParameteriv(sampler, pname, params);
3121         SetRobustLengthParam(length, numParams);
3122     }
3123 }
3124 
GetSamplerParameterfvRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)3125 ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterfvRobustANGLE(GLuint sampler,
3126                                                                GLenum pname,
3127                                                                GLsizei bufSize,
3128                                                                GLsizei *length,
3129                                                                GLfloat *params)
3130 {
3131     EVENT(
3132         "(GLuint sample = %ur, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
3133         "0x%0.8p, GLfloat* params = 0x%0.8p)",
3134         sampler, pname, bufSize, length, params);
3135 
3136     Context *context = GetValidGlobalContext();
3137     if (context)
3138     {
3139         GLsizei numParams = 0;
3140         if (!ValidateGetSamplerParameterfvRobustANGLE(context, sampler, pname, bufSize, &numParams,
3141                                                       params))
3142         {
3143             return;
3144         }
3145 
3146         context->getSamplerParameterfv(sampler, pname, params);
3147         SetRobustLengthParam(length, numParams);
3148     }
3149 }
3150 
GetFramebufferParameterivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3151 ANGLE_EXPORT void GL_APIENTRY GetFramebufferParameterivRobustANGLE(GLenum target,
3152                                                                    GLenum pname,
3153                                                                    GLsizei bufSize,
3154                                                                    GLsizei *length,
3155                                                                    GLint *params)
3156 {
3157     EVENT(
3158         "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
3159         "0x%0.8p, GLint* params = 0x%0.8p)",
3160         target, pname, bufSize, length, params);
3161     UNIMPLEMENTED();
3162 }
3163 
GetProgramInterfaceivRobustANGLE(GLuint program,GLenum programInterface,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3164 ANGLE_EXPORT void GL_APIENTRY GetProgramInterfaceivRobustANGLE(GLuint program,
3165                                                                GLenum programInterface,
3166                                                                GLenum pname,
3167                                                                GLsizei bufSize,
3168                                                                GLsizei *length,
3169                                                                GLint *params)
3170 {
3171     EVENT(
3172         "(GLuint program = %u, GLenum programInterface = 0x%X, GLenum pname = 0x%X, GLsizei "
3173         "bufsize = %d, GLsizei* length = 0x%0.8p, GLint* params = 0x%0.8p)",
3174         program, programInterface, pname, bufSize, length, params);
3175     UNIMPLEMENTED();
3176 }
3177 
GetBooleani_vRobustANGLE(GLenum target,GLuint index,GLsizei bufSize,GLsizei * length,GLboolean * data)3178 ANGLE_EXPORT void GL_APIENTRY GetBooleani_vRobustANGLE(GLenum target,
3179                                                        GLuint index,
3180                                                        GLsizei bufSize,
3181                                                        GLsizei *length,
3182                                                        GLboolean *data)
3183 {
3184     EVENT(
3185         "(GLenum target = 0x%X, GLuint index = %u, GLsizei bufsize = %d, GLsizei* length = "
3186         "0x%0.8p, GLboolean* data = 0x%0.8p)",
3187         target, index, bufSize, length, data);
3188     Context *context = GetValidGlobalContext();
3189     if (context)
3190     {
3191         GLsizei numParams = 0;
3192         if (!ValidateGetBooleani_vRobustANGLE(context, target, index, bufSize, &numParams, data))
3193         {
3194             return;
3195         }
3196 
3197         context->getBooleani_v(target, index, data);
3198         SetRobustLengthParam(length, numParams);
3199     }
3200 }
3201 
GetMultisamplefvRobustANGLE(GLenum pname,GLuint index,GLsizei bufSize,GLsizei * length,GLfloat * val)3202 ANGLE_EXPORT void GL_APIENTRY GetMultisamplefvRobustANGLE(GLenum pname,
3203                                                           GLuint index,
3204                                                           GLsizei bufSize,
3205                                                           GLsizei *length,
3206                                                           GLfloat *val)
3207 {
3208     EVENT(
3209         "(GLenum pname = 0x%X, GLuint index = %u, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, "
3210         "GLfloat* val = 0x%0.8p)",
3211         pname, index, bufSize, length, val);
3212     UNIMPLEMENTED();
3213 }
3214 
GetTexLevelParameterivRobustANGLE(GLenum target,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3215 ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterivRobustANGLE(GLenum target,
3216                                                                 GLint level,
3217                                                                 GLenum pname,
3218                                                                 GLsizei bufSize,
3219                                                                 GLsizei *length,
3220                                                                 GLint *params)
3221 {
3222     EVENT(
3223         "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLsizei bufsize = %d, "
3224         "GLsizei* length = 0x%0.8p, GLint* params = 0x%0.8p)",
3225         target, level, pname, bufSize, length, params);
3226     UNIMPLEMENTED();
3227 }
3228 
GetTexLevelParameterfvRobustANGLE(GLenum target,GLint level,GLenum pname,GLsizei bufSize,GLsizei * length,GLfloat * params)3229 ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterfvRobustANGLE(GLenum target,
3230                                                                 GLint level,
3231                                                                 GLenum pname,
3232                                                                 GLsizei bufSize,
3233                                                                 GLsizei *length,
3234                                                                 GLfloat *params)
3235 {
3236     EVENT(
3237         "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLsizei bufsize = %d, "
3238         "GLsizei* length = 0x%0.8p, GLfloat* params = 0x%0.8p)",
3239         target, level, pname, bufSize, length, params);
3240     UNIMPLEMENTED();
3241 }
3242 
GetPointervRobustANGLERobustANGLE(GLenum pname,GLsizei bufSize,GLsizei * length,void ** params)3243 ANGLE_EXPORT void GL_APIENTRY GetPointervRobustANGLERobustANGLE(GLenum pname,
3244                                                                 GLsizei bufSize,
3245                                                                 GLsizei *length,
3246                                                                 void **params)
3247 {
3248     EVENT(
3249         "(GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, void **params = "
3250         "0x%0.8p)",
3251         pname, bufSize, length, params);
3252     UNIMPLEMENTED();
3253 }
3254 
ReadnPixelsRobustANGLE(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLsizei * length,GLsizei * columns,GLsizei * rows,void * data)3255 ANGLE_EXPORT void GL_APIENTRY ReadnPixelsRobustANGLE(GLint x,
3256                                                      GLint y,
3257                                                      GLsizei width,
3258                                                      GLsizei height,
3259                                                      GLenum format,
3260                                                      GLenum type,
3261                                                      GLsizei bufSize,
3262                                                      GLsizei *length,
3263                                                      GLsizei *columns,
3264                                                      GLsizei *rows,
3265                                                      void *data)
3266 {
3267     EVENT(
3268         "(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
3269         "GLenum format = 0x%X, GLenum type = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
3270         "0x%0.8p, GLsizei* columns = 0x%0.8p, GLsizei* rows = 0x%0.8p, void *data = 0x%0.8p)",
3271         x, y, width, height, format, type, bufSize, length, columns, rows, data);
3272 
3273     Context *context = GetValidGlobalContext();
3274     if (context)
3275     {
3276         GLsizei writeLength  = 0;
3277         GLsizei writeColumns = 0;
3278         GLsizei writeRows    = 0;
3279         if (!ValidateReadnPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize,
3280                                             &writeLength, &writeColumns, &writeRows, data))
3281         {
3282             return;
3283         }
3284 
3285         context->readPixels(x, y, width, height, format, type, data);
3286 
3287         SetRobustLengthParam(length, writeLength);
3288         SetRobustLengthParam(columns, writeColumns);
3289         SetRobustLengthParam(rows, writeRows);
3290     }
3291 }
3292 
GetnUniformfvRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLfloat * params)3293 ANGLE_EXPORT void GL_APIENTRY GetnUniformfvRobustANGLE(GLuint program,
3294                                                        GLint location,
3295                                                        GLsizei bufSize,
3296                                                        GLsizei *length,
3297                                                        GLfloat *params)
3298 {
3299     EVENT(
3300         "(GLuint program = %d, GLint location = %d, GLsizei bufsize = %d, GLsizei* length = "
3301         "0x%0.8p, GLfloat* params = 0x%0.8p)",
3302         program, location, bufSize, length, params);
3303     UNIMPLEMENTED();
3304 }
3305 
GetnUniformivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLint * params)3306 ANGLE_EXPORT void GL_APIENTRY GetnUniformivRobustANGLE(GLuint program,
3307                                                        GLint location,
3308                                                        GLsizei bufSize,
3309                                                        GLsizei *length,
3310                                                        GLint *params)
3311 {
3312     EVENT(
3313         "(GLuint program = %d, GLint location = %d, GLsizei bufsize = %d, GLsizei* length = "
3314         "0x%0.8p, GLint* params = 0x%0.8p)",
3315         program, location, bufSize, length, params);
3316     UNIMPLEMENTED();
3317 }
3318 
GetnUniformuivRobustANGLE(GLuint program,GLint location,GLsizei bufSize,GLsizei * length,GLuint * params)3319 ANGLE_EXPORT void GL_APIENTRY GetnUniformuivRobustANGLE(GLuint program,
3320                                                         GLint location,
3321                                                         GLsizei bufSize,
3322                                                         GLsizei *length,
3323                                                         GLuint *params)
3324 {
3325     EVENT(
3326         "(GLuint program = %u, GLint location = %d, GLsizei bufsize = %d, GLsizei* length = "
3327         "0x%0.8p, GLuint* params = 0x%0.8p)",
3328         program, location, bufSize, length, params);
3329     UNIMPLEMENTED();
3330 }
3331 
TexParameterIivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLint * params)3332 ANGLE_EXPORT void GL_APIENTRY TexParameterIivRobustANGLE(GLenum target,
3333                                                          GLenum pname,
3334                                                          GLsizei bufSize,
3335                                                          const GLint *params)
3336 {
3337     EVENT(
3338         "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufsize = %d, const GLint *params = "
3339         "0x%0.8p)",
3340         target, pname, bufSize, params);
3341     UNIMPLEMENTED();
3342 }
3343 
TexParameterIuivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,const GLuint * params)3344 ANGLE_EXPORT void GL_APIENTRY TexParameterIuivRobustANGLE(GLenum target,
3345                                                           GLenum pname,
3346                                                           GLsizei bufSize,
3347                                                           const GLuint *params)
3348 {
3349     EVENT(
3350         "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufsize = %d, const GLuint *params = "
3351         "0x%0.8p)",
3352         target, pname, bufSize, params);
3353     UNIMPLEMENTED();
3354 }
3355 
GetTexParameterIivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3356 ANGLE_EXPORT void GL_APIENTRY GetTexParameterIivRobustANGLE(GLenum target,
3357                                                             GLenum pname,
3358                                                             GLsizei bufSize,
3359                                                             GLsizei *length,
3360                                                             GLint *params)
3361 {
3362     EVENT(
3363         "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
3364         "0x%0.8p, GLint *params = 0x%0.8p)",
3365         target, pname, bufSize, length, params);
3366     UNIMPLEMENTED();
3367 }
3368 
GetTexParameterIuivRobustANGLE(GLenum target,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)3369 ANGLE_EXPORT void GL_APIENTRY GetTexParameterIuivRobustANGLE(GLenum target,
3370                                                              GLenum pname,
3371                                                              GLsizei bufSize,
3372                                                              GLsizei *length,
3373                                                              GLuint *params)
3374 {
3375     EVENT(
3376         "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
3377         "0x%0.8p, GLuint *params = 0x%0.8p)",
3378         target, pname, bufSize, length, params);
3379     UNIMPLEMENTED();
3380 }
3381 
SamplerParameterIivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLint * param)3382 ANGLE_EXPORT void GL_APIENTRY SamplerParameterIivRobustANGLE(GLuint sampler,
3383                                                              GLenum pname,
3384                                                              GLsizei bufSize,
3385                                                              const GLint *param)
3386 {
3387     EVENT(
3388         "(GLuint sampler = %d, GLenum pname = 0x%X, GLsizei bufsize = %d, const GLint *param = "
3389         "0x%0.8p)",
3390         sampler, pname, bufSize, param);
3391     UNIMPLEMENTED();
3392 }
3393 
SamplerParameterIuivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,const GLuint * param)3394 ANGLE_EXPORT void GL_APIENTRY SamplerParameterIuivRobustANGLE(GLuint sampler,
3395                                                               GLenum pname,
3396                                                               GLsizei bufSize,
3397                                                               const GLuint *param)
3398 {
3399     EVENT(
3400         "(GLuint sampler = %d, GLenum pname = 0x%X, GLsizei bufsize = %d, const GLuint *param = "
3401         "0x%0.8p)",
3402         sampler, pname, bufSize, param);
3403     UNIMPLEMENTED();
3404 }
3405 
GetSamplerParameterIivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3406 ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterIivRobustANGLE(GLuint sampler,
3407                                                                 GLenum pname,
3408                                                                 GLsizei bufSize,
3409                                                                 GLsizei *length,
3410                                                                 GLint *params)
3411 {
3412     EVENT(
3413         "(GLuint sampler = %d, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
3414         "0x%0.8p, GLint *params = 0x%0.8p)",
3415         sampler, pname, bufSize, length, params);
3416     UNIMPLEMENTED();
3417 }
3418 
GetSamplerParameterIuivRobustANGLE(GLuint sampler,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint * params)3419 ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterIuivRobustANGLE(GLuint sampler,
3420                                                                  GLenum pname,
3421                                                                  GLsizei bufSize,
3422                                                                  GLsizei *length,
3423                                                                  GLuint *params)
3424 {
3425     EVENT(
3426         "(GLuint sampler = %d, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = "
3427         "0x%0.8p, GLuint *params = 0x%0.8p)",
3428         sampler, pname, bufSize, length, params);
3429     UNIMPLEMENTED();
3430 }
3431 
GetQueryObjectivRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLint * params)3432 ANGLE_EXPORT void GL_APIENTRY GetQueryObjectivRobustANGLE(GLuint id,
3433                                                           GLenum pname,
3434                                                           GLsizei bufSize,
3435                                                           GLsizei *length,
3436                                                           GLint *params)
3437 {
3438     EVENT(
3439         "(GLuint id = %d, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, "
3440         "GLuint *params = 0x%0.8p)",
3441         id, pname, bufSize, length, params);
3442 
3443     Context *context = GetValidGlobalContext();
3444     if (context)
3445     {
3446         GLsizei numParams = 0;
3447         if (!ValidateGetQueryObjectivRobustANGLE(context, id, pname, bufSize, &numParams, params))
3448         {
3449             return;
3450         }
3451 
3452         context->getQueryObjectiv(id, pname, params);
3453         SetRobustLengthParam(length, numParams);
3454     }
3455 }
3456 
GetQueryObjecti64vRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLint64 * params)3457 ANGLE_EXPORT void GL_APIENTRY GetQueryObjecti64vRobustANGLE(GLuint id,
3458                                                             GLenum pname,
3459                                                             GLsizei bufSize,
3460                                                             GLsizei *length,
3461                                                             GLint64 *params)
3462 {
3463     EVENT(
3464         "(GLuint id = %d, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, "
3465         "GLint64 *params = 0x%0.8p)",
3466         id, pname, bufSize, length, params);
3467 
3468     Context *context = GetValidGlobalContext();
3469     if (context)
3470     {
3471         GLsizei numParams = 0;
3472         if (!ValidateGetQueryObjecti64vRobustANGLE(context, id, pname, bufSize, &numParams, params))
3473         {
3474             return;
3475         }
3476 
3477         context->getQueryObjecti64v(id, pname, params);
3478         SetRobustLengthParam(length, numParams);
3479     }
3480 }
3481 
GetQueryObjectui64vRobustANGLE(GLuint id,GLenum pname,GLsizei bufSize,GLsizei * length,GLuint64 * params)3482 ANGLE_EXPORT void GL_APIENTRY GetQueryObjectui64vRobustANGLE(GLuint id,
3483                                                              GLenum pname,
3484                                                              GLsizei bufSize,
3485                                                              GLsizei *length,
3486                                                              GLuint64 *params)
3487 {
3488     EVENT(
3489         "(GLuint id = %d, GLenum pname = 0x%X, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, "
3490         "GLuint64 *params = 0x%0.8p)",
3491         id, pname, bufSize, length, params);
3492 
3493     Context *context = GetValidGlobalContext();
3494     if (context)
3495     {
3496         GLsizei numParams = 0;
3497         if (!ValidateGetQueryObjectui64vRobustANGLE(context, id, pname, bufSize, &numParams,
3498                                                     params))
3499         {
3500             return;
3501         }
3502 
3503         context->getQueryObjectui64v(id, pname, params);
3504         SetRobustLengthParam(length, numParams);
3505     }
3506 }
3507 
FramebufferTextureMultiviewLayeredANGLE(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint baseViewIndex,GLsizei numViews)3508 GL_APICALL void GL_APIENTRY FramebufferTextureMultiviewLayeredANGLE(GLenum target,
3509                                                                     GLenum attachment,
3510                                                                     GLuint texture,
3511                                                                     GLint level,
3512                                                                     GLint baseViewIndex,
3513                                                                     GLsizei numViews)
3514 {
3515     EVENT(
3516         "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLuint texture = %u, GLint level = %d, "
3517         "GLint baseViewIndex = %d, GLsizei numViews = %d)",
3518         target, attachment, texture, level, baseViewIndex, numViews);
3519     Context *context = GetValidGlobalContext();
3520     if (context)
3521     {
3522         if (!context->skipValidation() &&
3523             !ValidateFramebufferTextureMultiviewLayeredANGLE(context, target, attachment, texture,
3524                                                              level, baseViewIndex, numViews))
3525         {
3526             return;
3527         }
3528         context->framebufferTextureMultiviewLayeredANGLE(target, attachment, texture, level,
3529                                                          baseViewIndex, numViews);
3530     }
3531 }
3532 
FramebufferTextureMultiviewSideBySideANGLE(GLenum target,GLenum attachment,GLuint texture,GLint level,GLsizei numViews,const GLint * viewportOffsets)3533 GL_APICALL void GL_APIENTRY FramebufferTextureMultiviewSideBySideANGLE(GLenum target,
3534                                                                        GLenum attachment,
3535                                                                        GLuint texture,
3536                                                                        GLint level,
3537                                                                        GLsizei numViews,
3538                                                                        const GLint *viewportOffsets)
3539 {
3540     EVENT(
3541         "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLuint texture = %u, GLint level = %d, "
3542         "GLsizei numViews = %d, GLsizei* viewportOffsets = 0x%0.8p)",
3543         target, attachment, texture, level, numViews, viewportOffsets);
3544     Context *context = GetValidGlobalContext();
3545     if (context)
3546     {
3547         if (!context->skipValidation() &&
3548             !ValidateFramebufferTextureMultiviewSideBySideANGLE(
3549                 context, target, attachment, texture, level, numViews, viewportOffsets))
3550         {
3551             return;
3552         }
3553         context->framebufferTextureMultiviewSideBySideANGLE(target, attachment, texture, level,
3554                                                             numViews, viewportOffsets);
3555     }
3556 }
3557 
3558 }  // gl
3559