tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

validationGL4_autogen.h (75996B)


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