• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml.
3 //
4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // validationGL4_autogen.h:
9 //   Validation functions for the OpenGL Desktop GL 4.x entry points.
10 
11 #ifndef LIBANGLE_VALIDATION_GL4_AUTOGEN_H_
12 #define LIBANGLE_VALIDATION_GL4_AUTOGEN_H_
13 
14 #include "common/PackedEnums.h"
15 #include "common/entry_points_enum_autogen.h"
16 
17 namespace gl
18 {
19 class Context;
20 class PrivateState;
21 class ErrorSet;
22 
23 // GL 4.0
24 bool ValidateBeginQueryIndexed(const Context *context,
25                                angle::EntryPoint entryPoint,
26                                GLenum target,
27                                GLuint index,
28                                QueryID idPacked);
29 bool ValidateDrawTransformFeedback(const Context *context,
30                                    angle::EntryPoint entryPoint,
31                                    GLenum mode,
32                                    TransformFeedbackID idPacked);
33 bool ValidateDrawTransformFeedbackStream(const Context *context,
34                                          angle::EntryPoint entryPoint,
35                                          GLenum mode,
36                                          TransformFeedbackID idPacked,
37                                          GLuint stream);
38 bool ValidateEndQueryIndexed(const Context *context,
39                              angle::EntryPoint entryPoint,
40                              GLenum target,
41                              GLuint index);
42 bool ValidateGetActiveSubroutineName(const Context *context,
43                                      angle::EntryPoint entryPoint,
44                                      ShaderProgramID programPacked,
45                                      GLenum shadertype,
46                                      GLuint index,
47                                      GLsizei bufSize,
48                                      const GLsizei *length,
49                                      const GLchar *name);
50 bool ValidateGetActiveSubroutineUniformName(const Context *context,
51                                             angle::EntryPoint entryPoint,
52                                             ShaderProgramID programPacked,
53                                             GLenum shadertype,
54                                             GLuint index,
55                                             GLsizei bufSize,
56                                             const GLsizei *length,
57                                             const GLchar *name);
58 bool ValidateGetActiveSubroutineUniformiv(const Context *context,
59                                           angle::EntryPoint entryPoint,
60                                           ShaderProgramID programPacked,
61                                           GLenum shadertype,
62                                           GLuint index,
63                                           GLenum pname,
64                                           const GLint *values);
65 bool ValidateGetProgramStageiv(const Context *context,
66                                angle::EntryPoint entryPoint,
67                                ShaderProgramID programPacked,
68                                GLenum shadertype,
69                                GLenum pname,
70                                const GLint *values);
71 bool ValidateGetQueryIndexediv(const Context *context,
72                                angle::EntryPoint entryPoint,
73                                GLenum target,
74                                GLuint index,
75                                GLenum pname,
76                                const GLint *params);
77 bool ValidateGetSubroutineIndex(const Context *context,
78                                 angle::EntryPoint entryPoint,
79                                 ShaderProgramID programPacked,
80                                 GLenum shadertype,
81                                 const GLchar *name);
82 bool ValidateGetSubroutineUniformLocation(const Context *context,
83                                           angle::EntryPoint entryPoint,
84                                           ShaderProgramID programPacked,
85                                           GLenum shadertype,
86                                           const GLchar *name);
87 bool ValidateGetUniformSubroutineuiv(const Context *context,
88                                      angle::EntryPoint entryPoint,
89                                      GLenum shadertype,
90                                      GLint location,
91                                      const GLuint *params);
92 bool ValidateGetUniformdv(const Context *context,
93                           angle::EntryPoint entryPoint,
94                           ShaderProgramID programPacked,
95                           UniformLocation locationPacked,
96                           const GLdouble *params);
97 bool ValidatePatchParameterfv(const Context *context,
98                               angle::EntryPoint entryPoint,
99                               GLenum pname,
100                               const GLfloat *values);
101 bool ValidateUniform1d(const Context *context,
102                        angle::EntryPoint entryPoint,
103                        UniformLocation locationPacked,
104                        GLdouble x);
105 bool ValidateUniform1dv(const Context *context,
106                         angle::EntryPoint entryPoint,
107                         UniformLocation locationPacked,
108                         GLsizei count,
109                         const GLdouble *value);
110 bool ValidateUniform2d(const Context *context,
111                        angle::EntryPoint entryPoint,
112                        UniformLocation locationPacked,
113                        GLdouble x,
114                        GLdouble y);
115 bool ValidateUniform2dv(const Context *context,
116                         angle::EntryPoint entryPoint,
117                         UniformLocation locationPacked,
118                         GLsizei count,
119                         const GLdouble *value);
120 bool ValidateUniform3d(const Context *context,
121                        angle::EntryPoint entryPoint,
122                        UniformLocation locationPacked,
123                        GLdouble x,
124                        GLdouble y,
125                        GLdouble z);
126 bool ValidateUniform3dv(const Context *context,
127                         angle::EntryPoint entryPoint,
128                         UniformLocation locationPacked,
129                         GLsizei count,
130                         const GLdouble *value);
131 bool ValidateUniform4d(const Context *context,
132                        angle::EntryPoint entryPoint,
133                        UniformLocation locationPacked,
134                        GLdouble x,
135                        GLdouble y,
136                        GLdouble z,
137                        GLdouble w);
138 bool ValidateUniform4dv(const Context *context,
139                         angle::EntryPoint entryPoint,
140                         UniformLocation locationPacked,
141                         GLsizei count,
142                         const GLdouble *value);
143 bool ValidateUniformMatrix2dv(const Context *context,
144                               angle::EntryPoint entryPoint,
145                               UniformLocation locationPacked,
146                               GLsizei count,
147                               GLboolean transpose,
148                               const GLdouble *value);
149 bool ValidateUniformMatrix2x3dv(const Context *context,
150                                 angle::EntryPoint entryPoint,
151                                 UniformLocation locationPacked,
152                                 GLsizei count,
153                                 GLboolean transpose,
154                                 const GLdouble *value);
155 bool ValidateUniformMatrix2x4dv(const Context *context,
156                                 angle::EntryPoint entryPoint,
157                                 UniformLocation locationPacked,
158                                 GLsizei count,
159                                 GLboolean transpose,
160                                 const GLdouble *value);
161 bool ValidateUniformMatrix3dv(const Context *context,
162                               angle::EntryPoint entryPoint,
163                               UniformLocation locationPacked,
164                               GLsizei count,
165                               GLboolean transpose,
166                               const GLdouble *value);
167 bool ValidateUniformMatrix3x2dv(const Context *context,
168                                 angle::EntryPoint entryPoint,
169                                 UniformLocation locationPacked,
170                                 GLsizei count,
171                                 GLboolean transpose,
172                                 const GLdouble *value);
173 bool ValidateUniformMatrix3x4dv(const Context *context,
174                                 angle::EntryPoint entryPoint,
175                                 UniformLocation locationPacked,
176                                 GLsizei count,
177                                 GLboolean transpose,
178                                 const GLdouble *value);
179 bool ValidateUniformMatrix4dv(const Context *context,
180                               angle::EntryPoint entryPoint,
181                               UniformLocation locationPacked,
182                               GLsizei count,
183                               GLboolean transpose,
184                               const GLdouble *value);
185 bool ValidateUniformMatrix4x2dv(const Context *context,
186                                 angle::EntryPoint entryPoint,
187                                 UniformLocation locationPacked,
188                                 GLsizei count,
189                                 GLboolean transpose,
190                                 const GLdouble *value);
191 bool ValidateUniformMatrix4x3dv(const Context *context,
192                                 angle::EntryPoint entryPoint,
193                                 UniformLocation locationPacked,
194                                 GLsizei count,
195                                 GLboolean transpose,
196                                 const GLdouble *value);
197 bool ValidateUniformSubroutinesuiv(const Context *context,
198                                    angle::EntryPoint entryPoint,
199                                    GLenum shadertype,
200                                    GLsizei count,
201                                    const GLuint *indices);
202 
203 // GL 4.1
204 bool ValidateDepthRangeArrayv(const Context *context,
205                               angle::EntryPoint entryPoint,
206                               GLuint first,
207                               GLsizei count,
208                               const GLdouble *v);
209 bool ValidateDepthRangeIndexed(const Context *context,
210                                angle::EntryPoint entryPoint,
211                                GLuint index,
212                                GLdouble n,
213                                GLdouble f);
214 bool ValidateGetDoublei_v(const Context *context,
215                           angle::EntryPoint entryPoint,
216                           GLenum target,
217                           GLuint index,
218                           const GLdouble *data);
219 bool ValidateGetFloati_v(const Context *context,
220                          angle::EntryPoint entryPoint,
221                          GLenum target,
222                          GLuint index,
223                          const GLfloat *data);
224 bool ValidateGetVertexAttribLdv(const Context *context,
225                                 angle::EntryPoint entryPoint,
226                                 GLuint index,
227                                 GLenum pname,
228                                 const GLdouble *params);
229 bool ValidateProgramUniform1d(const Context *context,
230                               angle::EntryPoint entryPoint,
231                               ShaderProgramID programPacked,
232                               UniformLocation locationPacked,
233                               GLdouble v0);
234 bool ValidateProgramUniform1dv(const Context *context,
235                                angle::EntryPoint entryPoint,
236                                ShaderProgramID programPacked,
237                                UniformLocation locationPacked,
238                                GLsizei count,
239                                const GLdouble *value);
240 bool ValidateProgramUniform2d(const Context *context,
241                               angle::EntryPoint entryPoint,
242                               ShaderProgramID programPacked,
243                               UniformLocation locationPacked,
244                               GLdouble v0,
245                               GLdouble v1);
246 bool ValidateProgramUniform2dv(const Context *context,
247                                angle::EntryPoint entryPoint,
248                                ShaderProgramID programPacked,
249                                UniformLocation locationPacked,
250                                GLsizei count,
251                                const GLdouble *value);
252 bool ValidateProgramUniform3d(const Context *context,
253                               angle::EntryPoint entryPoint,
254                               ShaderProgramID programPacked,
255                               UniformLocation locationPacked,
256                               GLdouble v0,
257                               GLdouble v1,
258                               GLdouble v2);
259 bool ValidateProgramUniform3dv(const Context *context,
260                                angle::EntryPoint entryPoint,
261                                ShaderProgramID programPacked,
262                                UniformLocation locationPacked,
263                                GLsizei count,
264                                const GLdouble *value);
265 bool ValidateProgramUniform4d(const Context *context,
266                               angle::EntryPoint entryPoint,
267                               ShaderProgramID programPacked,
268                               UniformLocation locationPacked,
269                               GLdouble v0,
270                               GLdouble v1,
271                               GLdouble v2,
272                               GLdouble v3);
273 bool ValidateProgramUniform4dv(const Context *context,
274                                angle::EntryPoint entryPoint,
275                                ShaderProgramID programPacked,
276                                UniformLocation locationPacked,
277                                GLsizei count,
278                                const GLdouble *value);
279 bool ValidateProgramUniformMatrix2dv(const Context *context,
280                                      angle::EntryPoint entryPoint,
281                                      ShaderProgramID programPacked,
282                                      UniformLocation locationPacked,
283                                      GLsizei count,
284                                      GLboolean transpose,
285                                      const GLdouble *value);
286 bool ValidateProgramUniformMatrix2x3dv(const Context *context,
287                                        angle::EntryPoint entryPoint,
288                                        ShaderProgramID programPacked,
289                                        UniformLocation locationPacked,
290                                        GLsizei count,
291                                        GLboolean transpose,
292                                        const GLdouble *value);
293 bool ValidateProgramUniformMatrix2x4dv(const Context *context,
294                                        angle::EntryPoint entryPoint,
295                                        ShaderProgramID programPacked,
296                                        UniformLocation locationPacked,
297                                        GLsizei count,
298                                        GLboolean transpose,
299                                        const GLdouble *value);
300 bool ValidateProgramUniformMatrix3dv(const Context *context,
301                                      angle::EntryPoint entryPoint,
302                                      ShaderProgramID programPacked,
303                                      UniformLocation locationPacked,
304                                      GLsizei count,
305                                      GLboolean transpose,
306                                      const GLdouble *value);
307 bool ValidateProgramUniformMatrix3x2dv(const Context *context,
308                                        angle::EntryPoint entryPoint,
309                                        ShaderProgramID programPacked,
310                                        UniformLocation locationPacked,
311                                        GLsizei count,
312                                        GLboolean transpose,
313                                        const GLdouble *value);
314 bool ValidateProgramUniformMatrix3x4dv(const Context *context,
315                                        angle::EntryPoint entryPoint,
316                                        ShaderProgramID programPacked,
317                                        UniformLocation locationPacked,
318                                        GLsizei count,
319                                        GLboolean transpose,
320                                        const GLdouble *value);
321 bool ValidateProgramUniformMatrix4dv(const Context *context,
322                                      angle::EntryPoint entryPoint,
323                                      ShaderProgramID programPacked,
324                                      UniformLocation locationPacked,
325                                      GLsizei count,
326                                      GLboolean transpose,
327                                      const GLdouble *value);
328 bool ValidateProgramUniformMatrix4x2dv(const Context *context,
329                                        angle::EntryPoint entryPoint,
330                                        ShaderProgramID programPacked,
331                                        UniformLocation locationPacked,
332                                        GLsizei count,
333                                        GLboolean transpose,
334                                        const GLdouble *value);
335 bool ValidateProgramUniformMatrix4x3dv(const Context *context,
336                                        angle::EntryPoint entryPoint,
337                                        ShaderProgramID programPacked,
338                                        UniformLocation locationPacked,
339                                        GLsizei count,
340                                        GLboolean transpose,
341                                        const GLdouble *value);
342 bool ValidateScissorArrayv(const Context *context,
343                            angle::EntryPoint entryPoint,
344                            GLuint first,
345                            GLsizei count,
346                            const GLint *v);
347 bool ValidateScissorIndexed(const Context *context,
348                             angle::EntryPoint entryPoint,
349                             GLuint index,
350                             GLint left,
351                             GLint bottom,
352                             GLsizei width,
353                             GLsizei height);
354 bool ValidateScissorIndexedv(const Context *context,
355                              angle::EntryPoint entryPoint,
356                              GLuint index,
357                              const GLint *v);
358 bool ValidateVertexAttribL1d(const PrivateState &state,
359                              ErrorSet *errors,
360                              angle::EntryPoint entryPoint,
361                              GLuint index,
362                              GLdouble x);
363 bool ValidateVertexAttribL1dv(const PrivateState &state,
364                               ErrorSet *errors,
365                               angle::EntryPoint entryPoint,
366                               GLuint index,
367                               const GLdouble *v);
368 bool ValidateVertexAttribL2d(const PrivateState &state,
369                              ErrorSet *errors,
370                              angle::EntryPoint entryPoint,
371                              GLuint index,
372                              GLdouble x,
373                              GLdouble y);
374 bool ValidateVertexAttribL2dv(const PrivateState &state,
375                               ErrorSet *errors,
376                               angle::EntryPoint entryPoint,
377                               GLuint index,
378                               const GLdouble *v);
379 bool ValidateVertexAttribL3d(const PrivateState &state,
380                              ErrorSet *errors,
381                              angle::EntryPoint entryPoint,
382                              GLuint index,
383                              GLdouble x,
384                              GLdouble y,
385                              GLdouble z);
386 bool ValidateVertexAttribL3dv(const PrivateState &state,
387                               ErrorSet *errors,
388                               angle::EntryPoint entryPoint,
389                               GLuint index,
390                               const GLdouble *v);
391 bool ValidateVertexAttribL4d(const PrivateState &state,
392                              ErrorSet *errors,
393                              angle::EntryPoint entryPoint,
394                              GLuint index,
395                              GLdouble x,
396                              GLdouble y,
397                              GLdouble z,
398                              GLdouble w);
399 bool ValidateVertexAttribL4dv(const PrivateState &state,
400                               ErrorSet *errors,
401                               angle::EntryPoint entryPoint,
402                               GLuint index,
403                               const GLdouble *v);
404 bool ValidateVertexAttribLPointer(const Context *context,
405                                   angle::EntryPoint entryPoint,
406                                   GLuint index,
407                                   GLint size,
408                                   GLenum type,
409                                   GLsizei stride,
410                                   const void *pointer);
411 bool ValidateViewportArrayv(const Context *context,
412                             angle::EntryPoint entryPoint,
413                             GLuint first,
414                             GLsizei count,
415                             const GLfloat *v);
416 bool ValidateViewportIndexedf(const Context *context,
417                               angle::EntryPoint entryPoint,
418                               GLuint index,
419                               GLfloat x,
420                               GLfloat y,
421                               GLfloat w,
422                               GLfloat h);
423 bool ValidateViewportIndexedfv(const Context *context,
424                                angle::EntryPoint entryPoint,
425                                GLuint index,
426                                const GLfloat *v);
427 
428 // GL 4.2
429 bool ValidateDrawArraysInstancedBaseInstance(const Context *context,
430                                              angle::EntryPoint entryPoint,
431                                              PrimitiveMode modePacked,
432                                              GLint first,
433                                              GLsizei count,
434                                              GLsizei instancecount,
435                                              GLuint baseinstance);
436 bool ValidateDrawElementsInstancedBaseInstance(const Context *context,
437                                                angle::EntryPoint entryPoint,
438                                                PrimitiveMode modePacked,
439                                                GLsizei count,
440                                                DrawElementsType typePacked,
441                                                const void *indices,
442                                                GLsizei instancecount,
443                                                GLuint baseinstance);
444 bool ValidateDrawElementsInstancedBaseVertexBaseInstance(const Context *context,
445                                                          angle::EntryPoint entryPoint,
446                                                          PrimitiveMode modePacked,
447                                                          GLsizei count,
448                                                          DrawElementsType typePacked,
449                                                          const void *indices,
450                                                          GLsizei instancecount,
451                                                          GLint basevertex,
452                                                          GLuint baseinstance);
453 bool ValidateDrawTransformFeedbackInstanced(const Context *context,
454                                             angle::EntryPoint entryPoint,
455                                             GLenum mode,
456                                             TransformFeedbackID idPacked,
457                                             GLsizei instancecount);
458 bool ValidateDrawTransformFeedbackStreamInstanced(const Context *context,
459                                                   angle::EntryPoint entryPoint,
460                                                   GLenum mode,
461                                                   TransformFeedbackID idPacked,
462                                                   GLuint stream,
463                                                   GLsizei instancecount);
464 bool ValidateGetActiveAtomicCounterBufferiv(const Context *context,
465                                             angle::EntryPoint entryPoint,
466                                             ShaderProgramID programPacked,
467                                             GLuint bufferIndex,
468                                             GLenum pname,
469                                             const GLint *params);
470 bool ValidateTexStorage1D(const Context *context,
471                           angle::EntryPoint entryPoint,
472                           GLenum target,
473                           GLsizei levels,
474                           GLenum internalformat,
475                           GLsizei width);
476 
477 // GL 4.3
478 bool ValidateClearBufferData(const Context *context,
479                              angle::EntryPoint entryPoint,
480                              GLenum target,
481                              GLenum internalformat,
482                              GLenum format,
483                              GLenum type,
484                              const void *data);
485 bool ValidateClearBufferSubData(const Context *context,
486                                 angle::EntryPoint entryPoint,
487                                 GLenum target,
488                                 GLenum internalformat,
489                                 GLintptr offset,
490                                 GLsizeiptr size,
491                                 GLenum format,
492                                 GLenum type,
493                                 const void *data);
494 bool ValidateGetInternalformati64v(const Context *context,
495                                    angle::EntryPoint entryPoint,
496                                    GLenum target,
497                                    GLenum internalformat,
498                                    GLenum pname,
499                                    GLsizei count,
500                                    const GLint64 *params);
501 bool ValidateGetProgramResourceLocationIndex(const Context *context,
502                                              angle::EntryPoint entryPoint,
503                                              ShaderProgramID programPacked,
504                                              GLenum programInterface,
505                                              const GLchar *name);
506 bool ValidateInvalidateBufferData(const Context *context,
507                                   angle::EntryPoint entryPoint,
508                                   BufferID bufferPacked);
509 bool ValidateInvalidateBufferSubData(const Context *context,
510                                      angle::EntryPoint entryPoint,
511                                      BufferID bufferPacked,
512                                      GLintptr offset,
513                                      GLsizeiptr length);
514 bool ValidateInvalidateTexImage(const Context *context,
515                                 angle::EntryPoint entryPoint,
516                                 TextureID texturePacked,
517                                 GLint level);
518 bool ValidateInvalidateTexSubImage(const Context *context,
519                                    angle::EntryPoint entryPoint,
520                                    TextureID texturePacked,
521                                    GLint level,
522                                    GLint xoffset,
523                                    GLint yoffset,
524                                    GLint zoffset,
525                                    GLsizei width,
526                                    GLsizei height,
527                                    GLsizei depth);
528 bool ValidateMultiDrawArraysIndirect(const Context *context,
529                                      angle::EntryPoint entryPoint,
530                                      PrimitiveMode modePacked,
531                                      const void *indirect,
532                                      GLsizei drawcount,
533                                      GLsizei stride);
534 bool ValidateMultiDrawElementsIndirect(const Context *context,
535                                        angle::EntryPoint entryPoint,
536                                        PrimitiveMode modePacked,
537                                        DrawElementsType typePacked,
538                                        const void *indirect,
539                                        GLsizei drawcount,
540                                        GLsizei stride);
541 bool ValidateShaderStorageBlockBinding(const Context *context,
542                                        angle::EntryPoint entryPoint,
543                                        ShaderProgramID programPacked,
544                                        GLuint storageBlockIndex,
545                                        GLuint storageBlockBinding);
546 bool ValidateTextureView(const Context *context,
547                          angle::EntryPoint entryPoint,
548                          TextureID texturePacked,
549                          GLenum target,
550                          GLuint origtexture,
551                          GLenum internalformat,
552                          GLuint minlevel,
553                          GLuint numlevels,
554                          GLuint minlayer,
555                          GLuint numlayers);
556 bool ValidateVertexAttribLFormat(const Context *context,
557                                  angle::EntryPoint entryPoint,
558                                  GLuint attribindex,
559                                  GLint size,
560                                  GLenum type,
561                                  GLuint relativeoffset);
562 
563 // GL 4.4
564 bool ValidateBindBuffersBase(const Context *context,
565                              angle::EntryPoint entryPoint,
566                              GLenum target,
567                              GLuint first,
568                              GLsizei count,
569                              const BufferID *buffersPacked);
570 bool ValidateBindBuffersRange(const Context *context,
571                               angle::EntryPoint entryPoint,
572                               GLenum target,
573                               GLuint first,
574                               GLsizei count,
575                               const BufferID *buffersPacked,
576                               const GLintptr *offsets,
577                               const GLsizeiptr *sizes);
578 bool ValidateBindImageTextures(const Context *context,
579                                angle::EntryPoint entryPoint,
580                                GLuint first,
581                                GLsizei count,
582                                const GLuint *textures);
583 bool ValidateBindSamplers(const Context *context,
584                           angle::EntryPoint entryPoint,
585                           GLuint first,
586                           GLsizei count,
587                           const GLuint *samplers);
588 bool ValidateBindTextures(const Context *context,
589                           angle::EntryPoint entryPoint,
590                           GLuint first,
591                           GLsizei count,
592                           const GLuint *textures);
593 bool ValidateBindVertexBuffers(const Context *context,
594                                angle::EntryPoint entryPoint,
595                                GLuint first,
596                                GLsizei count,
597                                const BufferID *buffersPacked,
598                                const GLintptr *offsets,
599                                const GLsizei *strides);
600 bool ValidateBufferStorage(const Context *context,
601                            angle::EntryPoint entryPoint,
602                            BufferBinding targetPacked,
603                            GLsizeiptr size,
604                            const void *data,
605                            GLbitfield flags);
606 bool ValidateClearTexImage(const Context *context,
607                            angle::EntryPoint entryPoint,
608                            TextureID texturePacked,
609                            GLint level,
610                            GLenum format,
611                            GLenum type,
612                            const void *data);
613 bool ValidateClearTexSubImage(const Context *context,
614                               angle::EntryPoint entryPoint,
615                               TextureID texturePacked,
616                               GLint level,
617                               GLint xoffset,
618                               GLint yoffset,
619                               GLint zoffset,
620                               GLsizei width,
621                               GLsizei height,
622                               GLsizei depth,
623                               GLenum format,
624                               GLenum type,
625                               const void *data);
626 
627 // GL 4.5
628 bool ValidateBindTextureUnit(const Context *context,
629                              angle::EntryPoint entryPoint,
630                              GLuint unit,
631                              TextureID texturePacked);
632 bool ValidateBlitNamedFramebuffer(const Context *context,
633                                   angle::EntryPoint entryPoint,
634                                   GLuint readFramebuffer,
635                                   GLuint drawFramebuffer,
636                                   GLint srcX0,
637                                   GLint srcY0,
638                                   GLint srcX1,
639                                   GLint srcY1,
640                                   GLint dstX0,
641                                   GLint dstY0,
642                                   GLint dstX1,
643                                   GLint dstY1,
644                                   GLbitfield mask,
645                                   GLenum filter);
646 bool ValidateCheckNamedFramebufferStatus(const Context *context,
647                                          angle::EntryPoint entryPoint,
648                                          FramebufferID framebufferPacked,
649                                          GLenum target);
650 bool ValidateClearNamedBufferData(const Context *context,
651                                   angle::EntryPoint entryPoint,
652                                   BufferID bufferPacked,
653                                   GLenum internalformat,
654                                   GLenum format,
655                                   GLenum type,
656                                   const void *data);
657 bool ValidateClearNamedBufferSubData(const Context *context,
658                                      angle::EntryPoint entryPoint,
659                                      BufferID bufferPacked,
660                                      GLenum internalformat,
661                                      GLintptr offset,
662                                      GLsizeiptr size,
663                                      GLenum format,
664                                      GLenum type,
665                                      const void *data);
666 bool ValidateClearNamedFramebufferfi(const Context *context,
667                                      angle::EntryPoint entryPoint,
668                                      FramebufferID framebufferPacked,
669                                      GLenum buffer,
670                                      GLint drawbuffer,
671                                      GLfloat depth,
672                                      GLint stencil);
673 bool ValidateClearNamedFramebufferfv(const Context *context,
674                                      angle::EntryPoint entryPoint,
675                                      FramebufferID framebufferPacked,
676                                      GLenum buffer,
677                                      GLint drawbuffer,
678                                      const GLfloat *value);
679 bool ValidateClearNamedFramebufferiv(const Context *context,
680                                      angle::EntryPoint entryPoint,
681                                      FramebufferID framebufferPacked,
682                                      GLenum buffer,
683                                      GLint drawbuffer,
684                                      const GLint *value);
685 bool ValidateClearNamedFramebufferuiv(const Context *context,
686                                       angle::EntryPoint entryPoint,
687                                       FramebufferID framebufferPacked,
688                                       GLenum buffer,
689                                       GLint drawbuffer,
690                                       const GLuint *value);
691 bool ValidateClipControl(const PrivateState &state,
692                          ErrorSet *errors,
693                          angle::EntryPoint entryPoint,
694                          ClipOrigin originPacked,
695                          ClipDepthMode depthPacked);
696 bool ValidateCompressedTextureSubImage1D(const Context *context,
697                                          angle::EntryPoint entryPoint,
698                                          TextureID texturePacked,
699                                          GLint level,
700                                          GLint xoffset,
701                                          GLsizei width,
702                                          GLenum format,
703                                          GLsizei imageSize,
704                                          const void *data);
705 bool ValidateCompressedTextureSubImage2D(const Context *context,
706                                          angle::EntryPoint entryPoint,
707                                          TextureID texturePacked,
708                                          GLint level,
709                                          GLint xoffset,
710                                          GLint yoffset,
711                                          GLsizei width,
712                                          GLsizei height,
713                                          GLenum format,
714                                          GLsizei imageSize,
715                                          const void *data);
716 bool ValidateCompressedTextureSubImage3D(const Context *context,
717                                          angle::EntryPoint entryPoint,
718                                          TextureID texturePacked,
719                                          GLint level,
720                                          GLint xoffset,
721                                          GLint yoffset,
722                                          GLint zoffset,
723                                          GLsizei width,
724                                          GLsizei height,
725                                          GLsizei depth,
726                                          GLenum format,
727                                          GLsizei imageSize,
728                                          const void *data);
729 bool ValidateCopyNamedBufferSubData(const Context *context,
730                                     angle::EntryPoint entryPoint,
731                                     GLuint readBuffer,
732                                     GLuint writeBuffer,
733                                     GLintptr readOffset,
734                                     GLintptr writeOffset,
735                                     GLsizeiptr size);
736 bool ValidateCopyTextureSubImage1D(const Context *context,
737                                    angle::EntryPoint entryPoint,
738                                    TextureID texturePacked,
739                                    GLint level,
740                                    GLint xoffset,
741                                    GLint x,
742                                    GLint y,
743                                    GLsizei width);
744 bool ValidateCopyTextureSubImage2D(const Context *context,
745                                    angle::EntryPoint entryPoint,
746                                    TextureID texturePacked,
747                                    GLint level,
748                                    GLint xoffset,
749                                    GLint yoffset,
750                                    GLint x,
751                                    GLint y,
752                                    GLsizei width,
753                                    GLsizei height);
754 bool ValidateCopyTextureSubImage3D(const Context *context,
755                                    angle::EntryPoint entryPoint,
756                                    TextureID texturePacked,
757                                    GLint level,
758                                    GLint xoffset,
759                                    GLint yoffset,
760                                    GLint zoffset,
761                                    GLint x,
762                                    GLint y,
763                                    GLsizei width,
764                                    GLsizei height);
765 bool ValidateCreateBuffers(const Context *context,
766                            angle::EntryPoint entryPoint,
767                            GLsizei n,
768                            const BufferID *buffersPacked);
769 bool ValidateCreateFramebuffers(const Context *context,
770                                 angle::EntryPoint entryPoint,
771                                 GLsizei n,
772                                 const GLuint *framebuffers);
773 bool ValidateCreateProgramPipelines(const Context *context,
774                                     angle::EntryPoint entryPoint,
775                                     GLsizei n,
776                                     const GLuint *pipelines);
777 bool ValidateCreateQueries(const Context *context,
778                            angle::EntryPoint entryPoint,
779                            GLenum target,
780                            GLsizei n,
781                            const GLuint *ids);
782 bool ValidateCreateRenderbuffers(const Context *context,
783                                  angle::EntryPoint entryPoint,
784                                  GLsizei n,
785                                  const RenderbufferID *renderbuffersPacked);
786 bool ValidateCreateSamplers(const Context *context,
787                             angle::EntryPoint entryPoint,
788                             GLsizei n,
789                             const GLuint *samplers);
790 bool ValidateCreateTextures(const Context *context,
791                             angle::EntryPoint entryPoint,
792                             GLenum target,
793                             GLsizei n,
794                             const GLuint *textures);
795 bool ValidateCreateTransformFeedbacks(const Context *context,
796                                       angle::EntryPoint entryPoint,
797                                       GLsizei n,
798                                       const GLuint *ids);
799 bool ValidateCreateVertexArrays(const Context *context,
800                                 angle::EntryPoint entryPoint,
801                                 GLsizei n,
802                                 const VertexArrayID *arraysPacked);
803 bool ValidateDisableVertexArrayAttrib(const Context *context,
804                                       angle::EntryPoint entryPoint,
805                                       VertexArrayID vaobjPacked,
806                                       GLuint index);
807 bool ValidateEnableVertexArrayAttrib(const Context *context,
808                                      angle::EntryPoint entryPoint,
809                                      VertexArrayID vaobjPacked,
810                                      GLuint index);
811 bool ValidateFlushMappedNamedBufferRange(const Context *context,
812                                          angle::EntryPoint entryPoint,
813                                          BufferID bufferPacked,
814                                          GLintptr offset,
815                                          GLsizeiptr length);
816 bool ValidateGenerateTextureMipmap(const Context *context,
817                                    angle::EntryPoint entryPoint,
818                                    TextureID texturePacked);
819 bool ValidateGetCompressedTextureImage(const Context *context,
820                                        angle::EntryPoint entryPoint,
821                                        TextureID texturePacked,
822                                        GLint level,
823                                        GLsizei bufSize,
824                                        const void *pixels);
825 bool ValidateGetCompressedTextureSubImage(const Context *context,
826                                           angle::EntryPoint entryPoint,
827                                           TextureID texturePacked,
828                                           GLint level,
829                                           GLint xoffset,
830                                           GLint yoffset,
831                                           GLint zoffset,
832                                           GLsizei width,
833                                           GLsizei height,
834                                           GLsizei depth,
835                                           GLsizei bufSize,
836                                           const void *pixels);
837 bool ValidateGetNamedBufferParameteri64v(const Context *context,
838                                          angle::EntryPoint entryPoint,
839                                          BufferID bufferPacked,
840                                          GLenum pname,
841                                          const GLint64 *params);
842 bool ValidateGetNamedBufferParameteriv(const Context *context,
843                                        angle::EntryPoint entryPoint,
844                                        BufferID bufferPacked,
845                                        GLenum pname,
846                                        const GLint *params);
847 bool ValidateGetNamedBufferPointerv(const Context *context,
848                                     angle::EntryPoint entryPoint,
849                                     BufferID bufferPacked,
850                                     GLenum pname,
851                                     void *const *params);
852 bool ValidateGetNamedBufferSubData(const Context *context,
853                                    angle::EntryPoint entryPoint,
854                                    BufferID bufferPacked,
855                                    GLintptr offset,
856                                    GLsizeiptr size,
857                                    const void *data);
858 bool ValidateGetNamedFramebufferAttachmentParameteriv(const Context *context,
859                                                       angle::EntryPoint entryPoint,
860                                                       FramebufferID framebufferPacked,
861                                                       GLenum attachment,
862                                                       GLenum pname,
863                                                       const GLint *params);
864 bool ValidateGetNamedFramebufferParameteriv(const Context *context,
865                                             angle::EntryPoint entryPoint,
866                                             FramebufferID framebufferPacked,
867                                             GLenum pname,
868                                             const GLint *param);
869 bool ValidateGetNamedRenderbufferParameteriv(const Context *context,
870                                              angle::EntryPoint entryPoint,
871                                              RenderbufferID renderbufferPacked,
872                                              GLenum pname,
873                                              const GLint *params);
874 bool ValidateGetQueryBufferObjecti64v(const Context *context,
875                                       angle::EntryPoint entryPoint,
876                                       GLuint id,
877                                       BufferID bufferPacked,
878                                       GLenum pname,
879                                       GLintptr offset);
880 bool ValidateGetQueryBufferObjectiv(const Context *context,
881                                     angle::EntryPoint entryPoint,
882                                     GLuint id,
883                                     BufferID bufferPacked,
884                                     GLenum pname,
885                                     GLintptr offset);
886 bool ValidateGetQueryBufferObjectui64v(const Context *context,
887                                        angle::EntryPoint entryPoint,
888                                        GLuint id,
889                                        BufferID bufferPacked,
890                                        GLenum pname,
891                                        GLintptr offset);
892 bool ValidateGetQueryBufferObjectuiv(const Context *context,
893                                      angle::EntryPoint entryPoint,
894                                      GLuint id,
895                                      BufferID bufferPacked,
896                                      GLenum pname,
897                                      GLintptr offset);
898 bool ValidateGetTextureImage(const Context *context,
899                              angle::EntryPoint entryPoint,
900                              TextureID texturePacked,
901                              GLint level,
902                              GLenum format,
903                              GLenum type,
904                              GLsizei bufSize,
905                              const void *pixels);
906 bool ValidateGetTextureLevelParameterfv(const Context *context,
907                                         angle::EntryPoint entryPoint,
908                                         TextureID texturePacked,
909                                         GLint level,
910                                         GLenum pname,
911                                         const GLfloat *params);
912 bool ValidateGetTextureLevelParameteriv(const Context *context,
913                                         angle::EntryPoint entryPoint,
914                                         TextureID texturePacked,
915                                         GLint level,
916                                         GLenum pname,
917                                         const GLint *params);
918 bool ValidateGetTextureParameterIiv(const Context *context,
919                                     angle::EntryPoint entryPoint,
920                                     TextureID texturePacked,
921                                     GLenum pname,
922                                     const GLint *params);
923 bool ValidateGetTextureParameterIuiv(const Context *context,
924                                      angle::EntryPoint entryPoint,
925                                      TextureID texturePacked,
926                                      GLenum pname,
927                                      const GLuint *params);
928 bool ValidateGetTextureParameterfv(const Context *context,
929                                    angle::EntryPoint entryPoint,
930                                    TextureID texturePacked,
931                                    GLenum pname,
932                                    const GLfloat *params);
933 bool ValidateGetTextureParameteriv(const Context *context,
934                                    angle::EntryPoint entryPoint,
935                                    TextureID texturePacked,
936                                    GLenum pname,
937                                    const GLint *params);
938 bool ValidateGetTextureSubImage(const Context *context,
939                                 angle::EntryPoint entryPoint,
940                                 TextureID texturePacked,
941                                 GLint level,
942                                 GLint xoffset,
943                                 GLint yoffset,
944                                 GLint zoffset,
945                                 GLsizei width,
946                                 GLsizei height,
947                                 GLsizei depth,
948                                 GLenum format,
949                                 GLenum type,
950                                 GLsizei bufSize,
951                                 const void *pixels);
952 bool ValidateGetTransformFeedbacki64_v(const Context *context,
953                                        angle::EntryPoint entryPoint,
954                                        GLuint xfb,
955                                        GLenum pname,
956                                        GLuint index,
957                                        const GLint64 *param);
958 bool ValidateGetTransformFeedbacki_v(const Context *context,
959                                      angle::EntryPoint entryPoint,
960                                      GLuint xfb,
961                                      GLenum pname,
962                                      GLuint index,
963                                      const GLint *param);
964 bool ValidateGetTransformFeedbackiv(const Context *context,
965                                     angle::EntryPoint entryPoint,
966                                     GLuint xfb,
967                                     GLenum pname,
968                                     const GLint *param);
969 bool ValidateGetVertexArrayIndexed64iv(const Context *context,
970                                        angle::EntryPoint entryPoint,
971                                        VertexArrayID vaobjPacked,
972                                        GLuint index,
973                                        GLenum pname,
974                                        const GLint64 *param);
975 bool ValidateGetVertexArrayIndexediv(const Context *context,
976                                      angle::EntryPoint entryPoint,
977                                      VertexArrayID vaobjPacked,
978                                      GLuint index,
979                                      GLenum pname,
980                                      const GLint *param);
981 bool ValidateGetVertexArrayiv(const Context *context,
982                               angle::EntryPoint entryPoint,
983                               VertexArrayID vaobjPacked,
984                               GLenum pname,
985                               const GLint *param);
986 bool ValidateGetnColorTable(const Context *context,
987                             angle::EntryPoint entryPoint,
988                             GLenum target,
989                             GLenum format,
990                             GLenum type,
991                             GLsizei bufSize,
992                             const void *table);
993 bool ValidateGetnCompressedTexImage(const Context *context,
994                                     angle::EntryPoint entryPoint,
995                                     GLenum target,
996                                     GLint lod,
997                                     GLsizei bufSize,
998                                     const void *pixels);
999 bool ValidateGetnConvolutionFilter(const Context *context,
1000                                    angle::EntryPoint entryPoint,
1001                                    GLenum target,
1002                                    GLenum format,
1003                                    GLenum type,
1004                                    GLsizei bufSize,
1005                                    const void *image);
1006 bool ValidateGetnHistogram(const Context *context,
1007                            angle::EntryPoint entryPoint,
1008                            GLenum target,
1009                            GLboolean reset,
1010                            GLenum format,
1011                            GLenum type,
1012                            GLsizei bufSize,
1013                            const void *values);
1014 bool ValidateGetnMapdv(const Context *context,
1015                        angle::EntryPoint entryPoint,
1016                        GLenum target,
1017                        GLenum query,
1018                        GLsizei bufSize,
1019                        const GLdouble *v);
1020 bool ValidateGetnMapfv(const Context *context,
1021                        angle::EntryPoint entryPoint,
1022                        GLenum target,
1023                        GLenum query,
1024                        GLsizei bufSize,
1025                        const GLfloat *v);
1026 bool ValidateGetnMapiv(const Context *context,
1027                        angle::EntryPoint entryPoint,
1028                        GLenum target,
1029                        GLenum query,
1030                        GLsizei bufSize,
1031                        const GLint *v);
1032 bool ValidateGetnMinmax(const Context *context,
1033                         angle::EntryPoint entryPoint,
1034                         GLenum target,
1035                         GLboolean reset,
1036                         GLenum format,
1037                         GLenum type,
1038                         GLsizei bufSize,
1039                         const void *values);
1040 bool ValidateGetnPixelMapfv(const Context *context,
1041                             angle::EntryPoint entryPoint,
1042                             GLenum map,
1043                             GLsizei bufSize,
1044                             const GLfloat *values);
1045 bool ValidateGetnPixelMapuiv(const Context *context,
1046                              angle::EntryPoint entryPoint,
1047                              GLenum map,
1048                              GLsizei bufSize,
1049                              const GLuint *values);
1050 bool ValidateGetnPixelMapusv(const Context *context,
1051                              angle::EntryPoint entryPoint,
1052                              GLenum map,
1053                              GLsizei bufSize,
1054                              const GLushort *values);
1055 bool ValidateGetnPolygonStipple(const Context *context,
1056                                 angle::EntryPoint entryPoint,
1057                                 GLsizei bufSize,
1058                                 const GLubyte *pattern);
1059 bool ValidateGetnSeparableFilter(const Context *context,
1060                                  angle::EntryPoint entryPoint,
1061                                  GLenum target,
1062                                  GLenum format,
1063                                  GLenum type,
1064                                  GLsizei rowBufSize,
1065                                  const void *row,
1066                                  GLsizei columnBufSize,
1067                                  const void *column,
1068                                  const void *span);
1069 bool ValidateGetnTexImage(const Context *context,
1070                           angle::EntryPoint entryPoint,
1071                           GLenum target,
1072                           GLint level,
1073                           GLenum format,
1074                           GLenum type,
1075                           GLsizei bufSize,
1076                           const void *pixels);
1077 bool ValidateGetnUniformdv(const Context *context,
1078                            angle::EntryPoint entryPoint,
1079                            ShaderProgramID programPacked,
1080                            UniformLocation locationPacked,
1081                            GLsizei bufSize,
1082                            const GLdouble *params);
1083 bool ValidateInvalidateNamedFramebufferData(const Context *context,
1084                                             angle::EntryPoint entryPoint,
1085                                             FramebufferID framebufferPacked,
1086                                             GLsizei numAttachments,
1087                                             const GLenum *attachments);
1088 bool ValidateInvalidateNamedFramebufferSubData(const Context *context,
1089                                                angle::EntryPoint entryPoint,
1090                                                FramebufferID framebufferPacked,
1091                                                GLsizei numAttachments,
1092                                                const GLenum *attachments,
1093                                                GLint x,
1094                                                GLint y,
1095                                                GLsizei width,
1096                                                GLsizei height);
1097 bool ValidateMapNamedBuffer(const Context *context,
1098                             angle::EntryPoint entryPoint,
1099                             BufferID bufferPacked,
1100                             GLenum access);
1101 bool ValidateMapNamedBufferRange(const Context *context,
1102                                  angle::EntryPoint entryPoint,
1103                                  BufferID bufferPacked,
1104                                  GLintptr offset,
1105                                  GLsizeiptr length,
1106                                  GLbitfield access);
1107 bool ValidateNamedBufferData(const Context *context,
1108                              angle::EntryPoint entryPoint,
1109                              BufferID bufferPacked,
1110                              GLsizeiptr size,
1111                              const void *data,
1112                              GLenum usage);
1113 bool ValidateNamedBufferStorage(const Context *context,
1114                                 angle::EntryPoint entryPoint,
1115                                 BufferID bufferPacked,
1116                                 GLsizeiptr size,
1117                                 const void *data,
1118                                 GLbitfield flags);
1119 bool ValidateNamedBufferSubData(const Context *context,
1120                                 angle::EntryPoint entryPoint,
1121                                 BufferID bufferPacked,
1122                                 GLintptr offset,
1123                                 GLsizeiptr size,
1124                                 const void *data);
1125 bool ValidateNamedFramebufferDrawBuffer(const Context *context,
1126                                         angle::EntryPoint entryPoint,
1127                                         FramebufferID framebufferPacked,
1128                                         GLenum buf);
1129 bool ValidateNamedFramebufferDrawBuffers(const Context *context,
1130                                          angle::EntryPoint entryPoint,
1131                                          FramebufferID framebufferPacked,
1132                                          GLsizei n,
1133                                          const GLenum *bufs);
1134 bool ValidateNamedFramebufferParameteri(const Context *context,
1135                                         angle::EntryPoint entryPoint,
1136                                         FramebufferID framebufferPacked,
1137                                         GLenum pname,
1138                                         GLint param);
1139 bool ValidateNamedFramebufferReadBuffer(const Context *context,
1140                                         angle::EntryPoint entryPoint,
1141                                         FramebufferID framebufferPacked,
1142                                         GLenum src);
1143 bool ValidateNamedFramebufferRenderbuffer(const Context *context,
1144                                           angle::EntryPoint entryPoint,
1145                                           FramebufferID framebufferPacked,
1146                                           GLenum attachment,
1147                                           GLenum renderbuffertarget,
1148                                           RenderbufferID renderbufferPacked);
1149 bool ValidateNamedFramebufferTexture(const Context *context,
1150                                      angle::EntryPoint entryPoint,
1151                                      FramebufferID framebufferPacked,
1152                                      GLenum attachment,
1153                                      TextureID texturePacked,
1154                                      GLint level);
1155 bool ValidateNamedFramebufferTextureLayer(const Context *context,
1156                                           angle::EntryPoint entryPoint,
1157                                           FramebufferID framebufferPacked,
1158                                           GLenum attachment,
1159                                           TextureID texturePacked,
1160                                           GLint level,
1161                                           GLint layer);
1162 bool ValidateNamedRenderbufferStorage(const Context *context,
1163                                       angle::EntryPoint entryPoint,
1164                                       RenderbufferID renderbufferPacked,
1165                                       GLenum internalformat,
1166                                       GLsizei width,
1167                                       GLsizei height);
1168 bool ValidateNamedRenderbufferStorageMultisample(const Context *context,
1169                                                  angle::EntryPoint entryPoint,
1170                                                  RenderbufferID renderbufferPacked,
1171                                                  GLsizei samples,
1172                                                  GLenum internalformat,
1173                                                  GLsizei width,
1174                                                  GLsizei height);
1175 bool ValidateTextureBarrier(const Context *context, angle::EntryPoint entryPoint);
1176 bool ValidateTextureBuffer(const Context *context,
1177                            angle::EntryPoint entryPoint,
1178                            TextureID texturePacked,
1179                            GLenum internalformat,
1180                            BufferID bufferPacked);
1181 bool ValidateTextureBufferRange(const Context *context,
1182                                 angle::EntryPoint entryPoint,
1183                                 TextureID texturePacked,
1184                                 GLenum internalformat,
1185                                 BufferID bufferPacked,
1186                                 GLintptr offset,
1187                                 GLsizeiptr size);
1188 bool ValidateTextureParameterIiv(const Context *context,
1189                                  angle::EntryPoint entryPoint,
1190                                  TextureID texturePacked,
1191                                  GLenum pname,
1192                                  const GLint *params);
1193 bool ValidateTextureParameterIuiv(const Context *context,
1194                                   angle::EntryPoint entryPoint,
1195                                   TextureID texturePacked,
1196                                   GLenum pname,
1197                                   const GLuint *params);
1198 bool ValidateTextureParameterf(const Context *context,
1199                                angle::EntryPoint entryPoint,
1200                                TextureID texturePacked,
1201                                GLenum pname,
1202                                GLfloat param);
1203 bool ValidateTextureParameterfv(const Context *context,
1204                                 angle::EntryPoint entryPoint,
1205                                 TextureID texturePacked,
1206                                 GLenum pname,
1207                                 const GLfloat *param);
1208 bool ValidateTextureParameteri(const Context *context,
1209                                angle::EntryPoint entryPoint,
1210                                TextureID texturePacked,
1211                                GLenum pname,
1212                                GLint param);
1213 bool ValidateTextureParameteriv(const Context *context,
1214                                 angle::EntryPoint entryPoint,
1215                                 TextureID texturePacked,
1216                                 GLenum pname,
1217                                 const GLint *param);
1218 bool ValidateTextureStorage1D(const Context *context,
1219                               angle::EntryPoint entryPoint,
1220                               TextureID texturePacked,
1221                               GLsizei levels,
1222                               GLenum internalformat,
1223                               GLsizei width);
1224 bool ValidateTextureStorage2D(const Context *context,
1225                               angle::EntryPoint entryPoint,
1226                               TextureID texturePacked,
1227                               GLsizei levels,
1228                               GLenum internalformat,
1229                               GLsizei width,
1230                               GLsizei height);
1231 bool ValidateTextureStorage2DMultisample(const Context *context,
1232                                          angle::EntryPoint entryPoint,
1233                                          TextureID texturePacked,
1234                                          GLsizei samples,
1235                                          GLenum internalformat,
1236                                          GLsizei width,
1237                                          GLsizei height,
1238                                          GLboolean fixedsamplelocations);
1239 bool ValidateTextureStorage3D(const Context *context,
1240                               angle::EntryPoint entryPoint,
1241                               TextureID texturePacked,
1242                               GLsizei levels,
1243                               GLenum internalformat,
1244                               GLsizei width,
1245                               GLsizei height,
1246                               GLsizei depth);
1247 bool ValidateTextureStorage3DMultisample(const Context *context,
1248                                          angle::EntryPoint entryPoint,
1249                                          TextureID texturePacked,
1250                                          GLsizei samples,
1251                                          GLenum internalformat,
1252                                          GLsizei width,
1253                                          GLsizei height,
1254                                          GLsizei depth,
1255                                          GLboolean fixedsamplelocations);
1256 bool ValidateTextureSubImage1D(const Context *context,
1257                                angle::EntryPoint entryPoint,
1258                                TextureID texturePacked,
1259                                GLint level,
1260                                GLint xoffset,
1261                                GLsizei width,
1262                                GLenum format,
1263                                GLenum type,
1264                                const void *pixels);
1265 bool ValidateTextureSubImage2D(const Context *context,
1266                                angle::EntryPoint entryPoint,
1267                                TextureID texturePacked,
1268                                GLint level,
1269                                GLint xoffset,
1270                                GLint yoffset,
1271                                GLsizei width,
1272                                GLsizei height,
1273                                GLenum format,
1274                                GLenum type,
1275                                const void *pixels);
1276 bool ValidateTextureSubImage3D(const Context *context,
1277                                angle::EntryPoint entryPoint,
1278                                TextureID texturePacked,
1279                                GLint level,
1280                                GLint xoffset,
1281                                GLint yoffset,
1282                                GLint zoffset,
1283                                GLsizei width,
1284                                GLsizei height,
1285                                GLsizei depth,
1286                                GLenum format,
1287                                GLenum type,
1288                                const void *pixels);
1289 bool ValidateTransformFeedbackBufferBase(const Context *context,
1290                                          angle::EntryPoint entryPoint,
1291                                          GLuint xfb,
1292                                          GLuint index,
1293                                          BufferID bufferPacked);
1294 bool ValidateTransformFeedbackBufferRange(const Context *context,
1295                                           angle::EntryPoint entryPoint,
1296                                           GLuint xfb,
1297                                           GLuint index,
1298                                           BufferID bufferPacked,
1299                                           GLintptr offset,
1300                                           GLsizeiptr size);
1301 bool ValidateUnmapNamedBuffer(const Context *context,
1302                               angle::EntryPoint entryPoint,
1303                               BufferID bufferPacked);
1304 bool ValidateVertexArrayAttribBinding(const Context *context,
1305                                       angle::EntryPoint entryPoint,
1306                                       VertexArrayID vaobjPacked,
1307                                       GLuint attribindex,
1308                                       GLuint bindingindex);
1309 bool ValidateVertexArrayAttribFormat(const Context *context,
1310                                      angle::EntryPoint entryPoint,
1311                                      VertexArrayID vaobjPacked,
1312                                      GLuint attribindex,
1313                                      GLint size,
1314                                      GLenum type,
1315                                      GLboolean normalized,
1316                                      GLuint relativeoffset);
1317 bool ValidateVertexArrayAttribIFormat(const Context *context,
1318                                       angle::EntryPoint entryPoint,
1319                                       VertexArrayID vaobjPacked,
1320                                       GLuint attribindex,
1321                                       GLint size,
1322                                       GLenum type,
1323                                       GLuint relativeoffset);
1324 bool ValidateVertexArrayAttribLFormat(const Context *context,
1325                                       angle::EntryPoint entryPoint,
1326                                       VertexArrayID vaobjPacked,
1327                                       GLuint attribindex,
1328                                       GLint size,
1329                                       GLenum type,
1330                                       GLuint relativeoffset);
1331 bool ValidateVertexArrayBindingDivisor(const Context *context,
1332                                        angle::EntryPoint entryPoint,
1333                                        VertexArrayID vaobjPacked,
1334                                        GLuint bindingindex,
1335                                        GLuint divisor);
1336 bool ValidateVertexArrayElementBuffer(const Context *context,
1337                                       angle::EntryPoint entryPoint,
1338                                       VertexArrayID vaobjPacked,
1339                                       BufferID bufferPacked);
1340 bool ValidateVertexArrayVertexBuffer(const Context *context,
1341                                      angle::EntryPoint entryPoint,
1342                                      VertexArrayID vaobjPacked,
1343                                      GLuint bindingindex,
1344                                      BufferID bufferPacked,
1345                                      GLintptr offset,
1346                                      GLsizei stride);
1347 bool ValidateVertexArrayVertexBuffers(const Context *context,
1348                                       angle::EntryPoint entryPoint,
1349                                       VertexArrayID vaobjPacked,
1350                                       GLuint first,
1351                                       GLsizei count,
1352                                       const BufferID *buffersPacked,
1353                                       const GLintptr *offsets,
1354                                       const GLsizei *strides);
1355 
1356 // GL 4.6
1357 bool ValidateMultiDrawArraysIndirectCount(const Context *context,
1358                                           angle::EntryPoint entryPoint,
1359                                           GLenum mode,
1360                                           const void *indirect,
1361                                           GLintptr drawcount,
1362                                           GLsizei maxdrawcount,
1363                                           GLsizei stride);
1364 bool ValidateMultiDrawElementsIndirectCount(const Context *context,
1365                                             angle::EntryPoint entryPoint,
1366                                             GLenum mode,
1367                                             GLenum type,
1368                                             const void *indirect,
1369                                             GLintptr drawcount,
1370                                             GLsizei maxdrawcount,
1371                                             GLsizei stride);
1372 bool ValidatePolygonOffsetClamp(const PrivateState &state,
1373                                 ErrorSet *errors,
1374                                 angle::EntryPoint entryPoint,
1375                                 GLfloat factor,
1376                                 GLfloat units,
1377                                 GLfloat clamp);
1378 bool ValidateSpecializeShader(const Context *context,
1379                               angle::EntryPoint entryPoint,
1380                               GLuint shader,
1381                               const GLchar *pEntryPoint,
1382                               GLuint numSpecializationConstants,
1383                               const GLuint *pConstantIndex,
1384                               const GLuint *pConstantValue);
1385 }  // namespace gl
1386 
1387 #endif  // LIBANGLE_VALIDATION_GL4_AUTOGEN_H_
1388