xref: /aosp_15_r20/external/angle/src/libANGLE/validationES2_autogen.h (revision 8975f5c5ed3d1c378011245431ada316dfb6f244) 
1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.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 // validationES2_autogen.h:
9 //   Validation functions for the OpenGL ES 2.0 entry points.
10 
11 #ifndef LIBANGLE_VALIDATION_ES2_AUTOGEN_H_
12 #define LIBANGLE_VALIDATION_ES2_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 bool ValidateActiveTexture(const PrivateState &state,
24                            ErrorSet *errors,
25                            angle::EntryPoint entryPoint,
26                            GLenum texture);
27 bool ValidateAttachShader(const Context *context,
28                           angle::EntryPoint entryPoint,
29                           ShaderProgramID programPacked,
30                           ShaderProgramID shaderPacked);
31 bool ValidateBindAttribLocation(const Context *context,
32                                 angle::EntryPoint entryPoint,
33                                 ShaderProgramID programPacked,
34                                 GLuint index,
35                                 const GLchar *name);
36 bool ValidateBindBuffer(const Context *context,
37                         angle::EntryPoint entryPoint,
38                         BufferBinding targetPacked,
39                         BufferID bufferPacked);
40 bool ValidateBindFramebuffer(const Context *context,
41                              angle::EntryPoint entryPoint,
42                              GLenum target,
43                              FramebufferID framebufferPacked);
44 bool ValidateBindRenderbuffer(const Context *context,
45                               angle::EntryPoint entryPoint,
46                               GLenum target,
47                               RenderbufferID renderbufferPacked);
48 bool ValidateBindTexture(const Context *context,
49                          angle::EntryPoint entryPoint,
50                          TextureType targetPacked,
51                          TextureID texturePacked);
52 bool ValidateBlendColor(const PrivateState &state,
53                         ErrorSet *errors,
54                         angle::EntryPoint entryPoint,
55                         GLfloat red,
56                         GLfloat green,
57                         GLfloat blue,
58                         GLfloat alpha);
59 bool ValidateBlendEquation(const PrivateState &state,
60                            ErrorSet *errors,
61                            angle::EntryPoint entryPoint,
62                            GLenum mode);
63 bool ValidateBlendEquationSeparate(const PrivateState &state,
64                                    ErrorSet *errors,
65                                    angle::EntryPoint entryPoint,
66                                    GLenum modeRGB,
67                                    GLenum modeAlpha);
68 bool ValidateBlendFunc(const PrivateState &state,
69                        ErrorSet *errors,
70                        angle::EntryPoint entryPoint,
71                        GLenum sfactor,
72                        GLenum dfactor);
73 bool ValidateBlendFuncSeparate(const PrivateState &state,
74                                ErrorSet *errors,
75                                angle::EntryPoint entryPoint,
76                                GLenum sfactorRGB,
77                                GLenum dfactorRGB,
78                                GLenum sfactorAlpha,
79                                GLenum dfactorAlpha);
80 bool ValidateBufferData(const Context *context,
81                         angle::EntryPoint entryPoint,
82                         BufferBinding targetPacked,
83                         GLsizeiptr size,
84                         const void *data,
85                         BufferUsage usagePacked);
86 bool ValidateBufferSubData(const Context *context,
87                            angle::EntryPoint entryPoint,
88                            BufferBinding targetPacked,
89                            GLintptr offset,
90                            GLsizeiptr size,
91                            const void *data);
92 bool ValidateCheckFramebufferStatus(const Context *context,
93                                     angle::EntryPoint entryPoint,
94                                     GLenum target);
95 bool ValidateClear(const Context *context, angle::EntryPoint entryPoint, GLbitfield mask);
96 bool ValidateClearColor(const PrivateState &state,
97                         ErrorSet *errors,
98                         angle::EntryPoint entryPoint,
99                         GLfloat red,
100                         GLfloat green,
101                         GLfloat blue,
102                         GLfloat alpha);
103 bool ValidateClearDepthf(const PrivateState &state,
104                          ErrorSet *errors,
105                          angle::EntryPoint entryPoint,
106                          GLfloat d);
107 bool ValidateClearStencil(const PrivateState &state,
108                           ErrorSet *errors,
109                           angle::EntryPoint entryPoint,
110                           GLint s);
111 bool ValidateColorMask(const PrivateState &state,
112                        ErrorSet *errors,
113                        angle::EntryPoint entryPoint,
114                        GLboolean red,
115                        GLboolean green,
116                        GLboolean blue,
117                        GLboolean alpha);
118 bool ValidateCompileShader(const Context *context,
119                            angle::EntryPoint entryPoint,
120                            ShaderProgramID shaderPacked);
121 bool ValidateCompressedTexImage2D(const Context *context,
122                                   angle::EntryPoint entryPoint,
123                                   TextureTarget targetPacked,
124                                   GLint level,
125                                   GLenum internalformat,
126                                   GLsizei width,
127                                   GLsizei height,
128                                   GLint border,
129                                   GLsizei imageSize,
130                                   const void *data);
131 bool ValidateCompressedTexSubImage2D(const Context *context,
132                                      angle::EntryPoint entryPoint,
133                                      TextureTarget targetPacked,
134                                      GLint level,
135                                      GLint xoffset,
136                                      GLint yoffset,
137                                      GLsizei width,
138                                      GLsizei height,
139                                      GLenum format,
140                                      GLsizei imageSize,
141                                      const void *data);
142 bool ValidateCopyTexImage2D(const Context *context,
143                             angle::EntryPoint entryPoint,
144                             TextureTarget targetPacked,
145                             GLint level,
146                             GLenum internalformat,
147                             GLint x,
148                             GLint y,
149                             GLsizei width,
150                             GLsizei height,
151                             GLint border);
152 bool ValidateCopyTexSubImage2D(const Context *context,
153                                angle::EntryPoint entryPoint,
154                                TextureTarget targetPacked,
155                                GLint level,
156                                GLint xoffset,
157                                GLint yoffset,
158                                GLint x,
159                                GLint y,
160                                GLsizei width,
161                                GLsizei height);
162 bool ValidateCreateProgram(const Context *context, angle::EntryPoint entryPoint);
163 bool ValidateCreateShader(const Context *context,
164                           angle::EntryPoint entryPoint,
165                           ShaderType typePacked);
166 bool ValidateCullFace(const PrivateState &state,
167                       ErrorSet *errors,
168                       angle::EntryPoint entryPoint,
169                       CullFaceMode modePacked);
170 bool ValidateDeleteBuffers(const Context *context,
171                            angle::EntryPoint entryPoint,
172                            GLsizei n,
173                            const BufferID *buffersPacked);
174 bool ValidateDeleteFramebuffers(const Context *context,
175                                 angle::EntryPoint entryPoint,
176                                 GLsizei n,
177                                 const FramebufferID *framebuffersPacked);
178 bool ValidateDeleteProgram(const Context *context,
179                            angle::EntryPoint entryPoint,
180                            ShaderProgramID programPacked);
181 bool ValidateDeleteRenderbuffers(const Context *context,
182                                  angle::EntryPoint entryPoint,
183                                  GLsizei n,
184                                  const RenderbufferID *renderbuffersPacked);
185 bool ValidateDeleteShader(const Context *context,
186                           angle::EntryPoint entryPoint,
187                           ShaderProgramID shaderPacked);
188 bool ValidateDeleteTextures(const Context *context,
189                             angle::EntryPoint entryPoint,
190                             GLsizei n,
191                             const TextureID *texturesPacked);
192 bool ValidateDepthFunc(const PrivateState &state,
193                        ErrorSet *errors,
194                        angle::EntryPoint entryPoint,
195                        GLenum func);
196 bool ValidateDepthMask(const PrivateState &state,
197                        ErrorSet *errors,
198                        angle::EntryPoint entryPoint,
199                        GLboolean flag);
200 bool ValidateDepthRangef(const PrivateState &state,
201                          ErrorSet *errors,
202                          angle::EntryPoint entryPoint,
203                          GLfloat n,
204                          GLfloat f);
205 bool ValidateDetachShader(const Context *context,
206                           angle::EntryPoint entryPoint,
207                           ShaderProgramID programPacked,
208                           ShaderProgramID shaderPacked);
209 bool ValidateDisable(const PrivateState &state,
210                      ErrorSet *errors,
211                      angle::EntryPoint entryPoint,
212                      GLenum cap);
213 bool ValidateDisableVertexAttribArray(const Context *context,
214                                       angle::EntryPoint entryPoint,
215                                       GLuint index);
216 bool ValidateDrawArrays(const Context *context,
217                         angle::EntryPoint entryPoint,
218                         PrimitiveMode modePacked,
219                         GLint first,
220                         GLsizei count);
221 bool ValidateDrawElements(const Context *context,
222                           angle::EntryPoint entryPoint,
223                           PrimitiveMode modePacked,
224                           GLsizei count,
225                           DrawElementsType typePacked,
226                           const void *indices);
227 bool ValidateEnable(const PrivateState &state,
228                     ErrorSet *errors,
229                     angle::EntryPoint entryPoint,
230                     GLenum cap);
231 bool ValidateEnableVertexAttribArray(const Context *context,
232                                      angle::EntryPoint entryPoint,
233                                      GLuint index);
234 bool ValidateFinish(const Context *context, angle::EntryPoint entryPoint);
235 bool ValidateFlush(const Context *context, angle::EntryPoint entryPoint);
236 bool ValidateFramebufferRenderbuffer(const Context *context,
237                                      angle::EntryPoint entryPoint,
238                                      GLenum target,
239                                      GLenum attachment,
240                                      GLenum renderbuffertarget,
241                                      RenderbufferID renderbufferPacked);
242 bool ValidateFramebufferTexture2D(const Context *context,
243                                   angle::EntryPoint entryPoint,
244                                   GLenum target,
245                                   GLenum attachment,
246                                   TextureTarget textargetPacked,
247                                   TextureID texturePacked,
248                                   GLint level);
249 bool ValidateFrontFace(const PrivateState &state,
250                        ErrorSet *errors,
251                        angle::EntryPoint entryPoint,
252                        GLenum mode);
253 bool ValidateGenBuffers(const Context *context,
254                         angle::EntryPoint entryPoint,
255                         GLsizei n,
256                         const BufferID *buffersPacked);
257 bool ValidateGenFramebuffers(const Context *context,
258                              angle::EntryPoint entryPoint,
259                              GLsizei n,
260                              const FramebufferID *framebuffersPacked);
261 bool ValidateGenRenderbuffers(const Context *context,
262                               angle::EntryPoint entryPoint,
263                               GLsizei n,
264                               const RenderbufferID *renderbuffersPacked);
265 bool ValidateGenTextures(const Context *context,
266                          angle::EntryPoint entryPoint,
267                          GLsizei n,
268                          const TextureID *texturesPacked);
269 bool ValidateGenerateMipmap(const Context *context,
270                             angle::EntryPoint entryPoint,
271                             TextureType targetPacked);
272 bool ValidateGetActiveAttrib(const Context *context,
273                              angle::EntryPoint entryPoint,
274                              ShaderProgramID programPacked,
275                              GLuint index,
276                              GLsizei bufSize,
277                              const GLsizei *length,
278                              const GLint *size,
279                              const GLenum *type,
280                              const GLchar *name);
281 bool ValidateGetActiveUniform(const Context *context,
282                               angle::EntryPoint entryPoint,
283                               ShaderProgramID programPacked,
284                               GLuint index,
285                               GLsizei bufSize,
286                               const GLsizei *length,
287                               const GLint *size,
288                               const GLenum *type,
289                               const GLchar *name);
290 bool ValidateGetAttachedShaders(const Context *context,
291                                 angle::EntryPoint entryPoint,
292                                 ShaderProgramID programPacked,
293                                 GLsizei maxCount,
294                                 const GLsizei *count,
295                                 const ShaderProgramID *shadersPacked);
296 bool ValidateGetAttribLocation(const Context *context,
297                                angle::EntryPoint entryPoint,
298                                ShaderProgramID programPacked,
299                                const GLchar *name);
300 bool ValidateGetBooleanv(const Context *context,
301                          angle::EntryPoint entryPoint,
302                          GLenum pname,
303                          const GLboolean *data);
304 bool ValidateGetBufferParameteriv(const Context *context,
305                                   angle::EntryPoint entryPoint,
306                                   BufferBinding targetPacked,
307                                   GLenum pname,
308                                   const GLint *params);
309 bool ValidateGetError(const Context *context, angle::EntryPoint entryPoint);
310 bool ValidateGetFloatv(const Context *context,
311                        angle::EntryPoint entryPoint,
312                        GLenum pname,
313                        const GLfloat *data);
314 bool ValidateGetFramebufferAttachmentParameteriv(const Context *context,
315                                                  angle::EntryPoint entryPoint,
316                                                  GLenum target,
317                                                  GLenum attachment,
318                                                  GLenum pname,
319                                                  const GLint *params);
320 bool ValidateGetIntegerv(const Context *context,
321                          angle::EntryPoint entryPoint,
322                          GLenum pname,
323                          const GLint *data);
324 bool ValidateGetProgramInfoLog(const Context *context,
325                                angle::EntryPoint entryPoint,
326                                ShaderProgramID programPacked,
327                                GLsizei bufSize,
328                                const GLsizei *length,
329                                const GLchar *infoLog);
330 bool ValidateGetProgramiv(const Context *context,
331                           angle::EntryPoint entryPoint,
332                           ShaderProgramID programPacked,
333                           GLenum pname,
334                           const GLint *params);
335 bool ValidateGetRenderbufferParameteriv(const Context *context,
336                                         angle::EntryPoint entryPoint,
337                                         GLenum target,
338                                         GLenum pname,
339                                         const GLint *params);
340 bool ValidateGetShaderInfoLog(const Context *context,
341                               angle::EntryPoint entryPoint,
342                               ShaderProgramID shaderPacked,
343                               GLsizei bufSize,
344                               const GLsizei *length,
345                               const GLchar *infoLog);
346 bool ValidateGetShaderPrecisionFormat(const Context *context,
347                                       angle::EntryPoint entryPoint,
348                                       GLenum shadertype,
349                                       GLenum precisiontype,
350                                       const GLint *range,
351                                       const GLint *precision);
352 bool ValidateGetShaderSource(const Context *context,
353                              angle::EntryPoint entryPoint,
354                              ShaderProgramID shaderPacked,
355                              GLsizei bufSize,
356                              const GLsizei *length,
357                              const GLchar *source);
358 bool ValidateGetShaderiv(const Context *context,
359                          angle::EntryPoint entryPoint,
360                          ShaderProgramID shaderPacked,
361                          GLenum pname,
362                          const GLint *params);
363 bool ValidateGetString(const Context *context, angle::EntryPoint entryPoint, GLenum name);
364 bool ValidateGetTexParameterfv(const Context *context,
365                                angle::EntryPoint entryPoint,
366                                TextureType targetPacked,
367                                GLenum pname,
368                                const GLfloat *params);
369 bool ValidateGetTexParameteriv(const Context *context,
370                                angle::EntryPoint entryPoint,
371                                TextureType targetPacked,
372                                GLenum pname,
373                                const GLint *params);
374 bool ValidateGetUniformLocation(const Context *context,
375                                 angle::EntryPoint entryPoint,
376                                 ShaderProgramID programPacked,
377                                 const GLchar *name);
378 bool ValidateGetUniformfv(const Context *context,
379                           angle::EntryPoint entryPoint,
380                           ShaderProgramID programPacked,
381                           UniformLocation locationPacked,
382                           const GLfloat *params);
383 bool ValidateGetUniformiv(const Context *context,
384                           angle::EntryPoint entryPoint,
385                           ShaderProgramID programPacked,
386                           UniformLocation locationPacked,
387                           const GLint *params);
388 bool ValidateGetVertexAttribPointerv(const Context *context,
389                                      angle::EntryPoint entryPoint,
390                                      GLuint index,
391                                      GLenum pname,
392                                      void *const *pointer);
393 bool ValidateGetVertexAttribfv(const Context *context,
394                                angle::EntryPoint entryPoint,
395                                GLuint index,
396                                GLenum pname,
397                                const GLfloat *params);
398 bool ValidateGetVertexAttribiv(const Context *context,
399                                angle::EntryPoint entryPoint,
400                                GLuint index,
401                                GLenum pname,
402                                const GLint *params);
403 bool ValidateHint(const PrivateState &state,
404                   ErrorSet *errors,
405                   angle::EntryPoint entryPoint,
406                   GLenum target,
407                   GLenum mode);
408 bool ValidateIsBuffer(const Context *context, angle::EntryPoint entryPoint, BufferID bufferPacked);
409 bool ValidateIsEnabled(const PrivateState &state,
410                        ErrorSet *errors,
411                        angle::EntryPoint entryPoint,
412                        GLenum cap);
413 bool ValidateIsFramebuffer(const Context *context,
414                            angle::EntryPoint entryPoint,
415                            FramebufferID framebufferPacked);
416 bool ValidateIsProgram(const Context *context,
417                        angle::EntryPoint entryPoint,
418                        ShaderProgramID programPacked);
419 bool ValidateIsRenderbuffer(const Context *context,
420                             angle::EntryPoint entryPoint,
421                             RenderbufferID renderbufferPacked);
422 bool ValidateIsShader(const Context *context,
423                       angle::EntryPoint entryPoint,
424                       ShaderProgramID shaderPacked);
425 bool ValidateIsTexture(const Context *context,
426                        angle::EntryPoint entryPoint,
427                        TextureID texturePacked);
428 bool ValidateLineWidth(const PrivateState &state,
429                        ErrorSet *errors,
430                        angle::EntryPoint entryPoint,
431                        GLfloat width);
432 bool ValidateLinkProgram(const Context *context,
433                          angle::EntryPoint entryPoint,
434                          ShaderProgramID programPacked);
435 bool ValidatePixelStorei(const PrivateState &state,
436                          ErrorSet *errors,
437                          angle::EntryPoint entryPoint,
438                          GLenum pname,
439                          GLint param);
440 bool ValidatePolygonOffset(const PrivateState &state,
441                            ErrorSet *errors,
442                            angle::EntryPoint entryPoint,
443                            GLfloat factor,
444                            GLfloat units);
445 bool ValidateReadPixels(const Context *context,
446                         angle::EntryPoint entryPoint,
447                         GLint x,
448                         GLint y,
449                         GLsizei width,
450                         GLsizei height,
451                         GLenum format,
452                         GLenum type,
453                         const void *pixels);
454 bool ValidateReleaseShaderCompiler(const Context *context, angle::EntryPoint entryPoint);
455 bool ValidateRenderbufferStorage(const Context *context,
456                                  angle::EntryPoint entryPoint,
457                                  GLenum target,
458                                  GLenum internalformat,
459                                  GLsizei width,
460                                  GLsizei height);
461 bool ValidateSampleCoverage(const PrivateState &state,
462                             ErrorSet *errors,
463                             angle::EntryPoint entryPoint,
464                             GLfloat value,
465                             GLboolean invert);
466 bool ValidateScissor(const PrivateState &state,
467                      ErrorSet *errors,
468                      angle::EntryPoint entryPoint,
469                      GLint x,
470                      GLint y,
471                      GLsizei width,
472                      GLsizei height);
473 bool ValidateShaderBinary(const Context *context,
474                           angle::EntryPoint entryPoint,
475                           GLsizei count,
476                           const ShaderProgramID *shadersPacked,
477                           GLenum binaryFormat,
478                           const void *binary,
479                           GLsizei length);
480 bool ValidateShaderSource(const Context *context,
481                           angle::EntryPoint entryPoint,
482                           ShaderProgramID shaderPacked,
483                           GLsizei count,
484                           const GLchar *const *string,
485                           const GLint *length);
486 bool ValidateStencilFunc(const PrivateState &state,
487                          ErrorSet *errors,
488                          angle::EntryPoint entryPoint,
489                          GLenum func,
490                          GLint ref,
491                          GLuint mask);
492 bool ValidateStencilFuncSeparate(const PrivateState &state,
493                                  ErrorSet *errors,
494                                  angle::EntryPoint entryPoint,
495                                  GLenum face,
496                                  GLenum func,
497                                  GLint ref,
498                                  GLuint mask);
499 bool ValidateStencilMask(const PrivateState &state,
500                          ErrorSet *errors,
501                          angle::EntryPoint entryPoint,
502                          GLuint mask);
503 bool ValidateStencilMaskSeparate(const PrivateState &state,
504                                  ErrorSet *errors,
505                                  angle::EntryPoint entryPoint,
506                                  GLenum face,
507                                  GLuint mask);
508 bool ValidateStencilOp(const PrivateState &state,
509                        ErrorSet *errors,
510                        angle::EntryPoint entryPoint,
511                        GLenum fail,
512                        GLenum zfail,
513                        GLenum zpass);
514 bool ValidateStencilOpSeparate(const PrivateState &state,
515                                ErrorSet *errors,
516                                angle::EntryPoint entryPoint,
517                                GLenum face,
518                                GLenum sfail,
519                                GLenum dpfail,
520                                GLenum dppass);
521 bool ValidateTexImage2D(const Context *context,
522                         angle::EntryPoint entryPoint,
523                         TextureTarget targetPacked,
524                         GLint level,
525                         GLint internalformat,
526                         GLsizei width,
527                         GLsizei height,
528                         GLint border,
529                         GLenum format,
530                         GLenum type,
531                         const void *pixels);
532 bool ValidateTexParameterf(const Context *context,
533                            angle::EntryPoint entryPoint,
534                            TextureType targetPacked,
535                            GLenum pname,
536                            GLfloat param);
537 bool ValidateTexParameterfv(const Context *context,
538                             angle::EntryPoint entryPoint,
539                             TextureType targetPacked,
540                             GLenum pname,
541                             const GLfloat *params);
542 bool ValidateTexParameteri(const Context *context,
543                            angle::EntryPoint entryPoint,
544                            TextureType targetPacked,
545                            GLenum pname,
546                            GLint param);
547 bool ValidateTexParameteriv(const Context *context,
548                             angle::EntryPoint entryPoint,
549                             TextureType targetPacked,
550                             GLenum pname,
551                             const GLint *params);
552 bool ValidateTexSubImage2D(const Context *context,
553                            angle::EntryPoint entryPoint,
554                            TextureTarget targetPacked,
555                            GLint level,
556                            GLint xoffset,
557                            GLint yoffset,
558                            GLsizei width,
559                            GLsizei height,
560                            GLenum format,
561                            GLenum type,
562                            const void *pixels);
563 bool ValidateUniform1f(const Context *context,
564                        angle::EntryPoint entryPoint,
565                        UniformLocation locationPacked,
566                        GLfloat v0);
567 bool ValidateUniform1fv(const Context *context,
568                         angle::EntryPoint entryPoint,
569                         UniformLocation locationPacked,
570                         GLsizei count,
571                         const GLfloat *value);
572 bool ValidateUniform1i(const Context *context,
573                        angle::EntryPoint entryPoint,
574                        UniformLocation locationPacked,
575                        GLint v0);
576 bool ValidateUniform1iv(const Context *context,
577                         angle::EntryPoint entryPoint,
578                         UniformLocation locationPacked,
579                         GLsizei count,
580                         const GLint *value);
581 bool ValidateUniform2f(const Context *context,
582                        angle::EntryPoint entryPoint,
583                        UniformLocation locationPacked,
584                        GLfloat v0,
585                        GLfloat v1);
586 bool ValidateUniform2fv(const Context *context,
587                         angle::EntryPoint entryPoint,
588                         UniformLocation locationPacked,
589                         GLsizei count,
590                         const GLfloat *value);
591 bool ValidateUniform2i(const Context *context,
592                        angle::EntryPoint entryPoint,
593                        UniformLocation locationPacked,
594                        GLint v0,
595                        GLint v1);
596 bool ValidateUniform2iv(const Context *context,
597                         angle::EntryPoint entryPoint,
598                         UniformLocation locationPacked,
599                         GLsizei count,
600                         const GLint *value);
601 bool ValidateUniform3f(const Context *context,
602                        angle::EntryPoint entryPoint,
603                        UniformLocation locationPacked,
604                        GLfloat v0,
605                        GLfloat v1,
606                        GLfloat v2);
607 bool ValidateUniform3fv(const Context *context,
608                         angle::EntryPoint entryPoint,
609                         UniformLocation locationPacked,
610                         GLsizei count,
611                         const GLfloat *value);
612 bool ValidateUniform3i(const Context *context,
613                        angle::EntryPoint entryPoint,
614                        UniformLocation locationPacked,
615                        GLint v0,
616                        GLint v1,
617                        GLint v2);
618 bool ValidateUniform3iv(const Context *context,
619                         angle::EntryPoint entryPoint,
620                         UniformLocation locationPacked,
621                         GLsizei count,
622                         const GLint *value);
623 bool ValidateUniform4f(const Context *context,
624                        angle::EntryPoint entryPoint,
625                        UniformLocation locationPacked,
626                        GLfloat v0,
627                        GLfloat v1,
628                        GLfloat v2,
629                        GLfloat v3);
630 bool ValidateUniform4fv(const Context *context,
631                         angle::EntryPoint entryPoint,
632                         UniformLocation locationPacked,
633                         GLsizei count,
634                         const GLfloat *value);
635 bool ValidateUniform4i(const Context *context,
636                        angle::EntryPoint entryPoint,
637                        UniformLocation locationPacked,
638                        GLint v0,
639                        GLint v1,
640                        GLint v2,
641                        GLint v3);
642 bool ValidateUniform4iv(const Context *context,
643                         angle::EntryPoint entryPoint,
644                         UniformLocation locationPacked,
645                         GLsizei count,
646                         const GLint *value);
647 bool ValidateUniformMatrix2fv(const Context *context,
648                               angle::EntryPoint entryPoint,
649                               UniformLocation locationPacked,
650                               GLsizei count,
651                               GLboolean transpose,
652                               const GLfloat *value);
653 bool ValidateUniformMatrix3fv(const Context *context,
654                               angle::EntryPoint entryPoint,
655                               UniformLocation locationPacked,
656                               GLsizei count,
657                               GLboolean transpose,
658                               const GLfloat *value);
659 bool ValidateUniformMatrix4fv(const Context *context,
660                               angle::EntryPoint entryPoint,
661                               UniformLocation locationPacked,
662                               GLsizei count,
663                               GLboolean transpose,
664                               const GLfloat *value);
665 bool ValidateUseProgram(const Context *context,
666                         angle::EntryPoint entryPoint,
667                         ShaderProgramID programPacked);
668 bool ValidateValidateProgram(const Context *context,
669                              angle::EntryPoint entryPoint,
670                              ShaderProgramID programPacked);
671 bool ValidateVertexAttrib1f(const PrivateState &state,
672                             ErrorSet *errors,
673                             angle::EntryPoint entryPoint,
674                             GLuint index,
675                             GLfloat x);
676 bool ValidateVertexAttrib1fv(const PrivateState &state,
677                              ErrorSet *errors,
678                              angle::EntryPoint entryPoint,
679                              GLuint index,
680                              const GLfloat *v);
681 bool ValidateVertexAttrib2f(const PrivateState &state,
682                             ErrorSet *errors,
683                             angle::EntryPoint entryPoint,
684                             GLuint index,
685                             GLfloat x,
686                             GLfloat y);
687 bool ValidateVertexAttrib2fv(const PrivateState &state,
688                              ErrorSet *errors,
689                              angle::EntryPoint entryPoint,
690                              GLuint index,
691                              const GLfloat *v);
692 bool ValidateVertexAttrib3f(const PrivateState &state,
693                             ErrorSet *errors,
694                             angle::EntryPoint entryPoint,
695                             GLuint index,
696                             GLfloat x,
697                             GLfloat y,
698                             GLfloat z);
699 bool ValidateVertexAttrib3fv(const PrivateState &state,
700                              ErrorSet *errors,
701                              angle::EntryPoint entryPoint,
702                              GLuint index,
703                              const GLfloat *v);
704 bool ValidateVertexAttrib4f(const PrivateState &state,
705                             ErrorSet *errors,
706                             angle::EntryPoint entryPoint,
707                             GLuint index,
708                             GLfloat x,
709                             GLfloat y,
710                             GLfloat z,
711                             GLfloat w);
712 bool ValidateVertexAttrib4fv(const PrivateState &state,
713                              ErrorSet *errors,
714                              angle::EntryPoint entryPoint,
715                              GLuint index,
716                              const GLfloat *v);
717 bool ValidateVertexAttribPointer(const Context *context,
718                                  angle::EntryPoint entryPoint,
719                                  GLuint index,
720                                  GLint size,
721                                  VertexAttribType typePacked,
722                                  GLboolean normalized,
723                                  GLsizei stride,
724                                  const void *pointer);
725 bool ValidateViewport(const PrivateState &state,
726                       ErrorSet *errors,
727                       angle::EntryPoint entryPoint,
728                       GLint x,
729                       GLint y,
730                       GLsizei width,
731                       GLsizei height);
732 }  // namespace gl
733 
734 #endif  // LIBANGLE_VALIDATION_ES2_AUTOGEN_H_
735