tor-browser

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

validationGL3_autogen.h (18084B)


      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 // validationGL3_autogen.h:
      9 //   Validation functions for the OpenGL Desktop GL 3.x entry points.
     10 
     11 #ifndef LIBANGLE_VALIDATION_GL3_AUTOGEN_H_
     12 #define LIBANGLE_VALIDATION_GL3_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 3.0
     22 bool ValidateBeginConditionalRender(const Context *context,
     23                                    angle::EntryPoint entryPoint,
     24                                    GLuint id,
     25                                    GLenum mode);
     26 bool ValidateBindFragDataLocation(const Context *context,
     27                                  angle::EntryPoint entryPoint,
     28                                  ShaderProgramID programPacked,
     29                                  GLuint color,
     30                                  const GLchar *name);
     31 bool ValidateClampColor(const Context *context,
     32                        angle::EntryPoint entryPoint,
     33                        GLenum target,
     34                        GLenum clamp);
     35 bool ValidateEndConditionalRender(const Context *context, angle::EntryPoint entryPoint);
     36 bool ValidateFramebufferTexture1D(const Context *context,
     37                                  angle::EntryPoint entryPoint,
     38                                  GLenum target,
     39                                  GLenum attachment,
     40                                  TextureTarget textargetPacked,
     41                                  TextureID texturePacked,
     42                                  GLint level);
     43 bool ValidateFramebufferTexture3D(const Context *context,
     44                                  angle::EntryPoint entryPoint,
     45                                  GLenum target,
     46                                  GLenum attachment,
     47                                  TextureTarget textargetPacked,
     48                                  TextureID texturePacked,
     49                                  GLint level,
     50                                  GLint zoffset);
     51 bool ValidateVertexAttribI1i(const Context *context,
     52                             angle::EntryPoint entryPoint,
     53                             GLuint index,
     54                             GLint x);
     55 bool ValidateVertexAttribI1iv(const Context *context,
     56                              angle::EntryPoint entryPoint,
     57                              GLuint index,
     58                              const GLint *v);
     59 bool ValidateVertexAttribI1ui(const Context *context,
     60                              angle::EntryPoint entryPoint,
     61                              GLuint index,
     62                              GLuint x);
     63 bool ValidateVertexAttribI1uiv(const Context *context,
     64                               angle::EntryPoint entryPoint,
     65                               GLuint index,
     66                               const GLuint *v);
     67 bool ValidateVertexAttribI2i(const Context *context,
     68                             angle::EntryPoint entryPoint,
     69                             GLuint index,
     70                             GLint x,
     71                             GLint y);
     72 bool ValidateVertexAttribI2iv(const Context *context,
     73                              angle::EntryPoint entryPoint,
     74                              GLuint index,
     75                              const GLint *v);
     76 bool ValidateVertexAttribI2ui(const Context *context,
     77                              angle::EntryPoint entryPoint,
     78                              GLuint index,
     79                              GLuint x,
     80                              GLuint y);
     81 bool ValidateVertexAttribI2uiv(const Context *context,
     82                               angle::EntryPoint entryPoint,
     83                               GLuint index,
     84                               const GLuint *v);
     85 bool ValidateVertexAttribI3i(const Context *context,
     86                             angle::EntryPoint entryPoint,
     87                             GLuint index,
     88                             GLint x,
     89                             GLint y,
     90                             GLint z);
     91 bool ValidateVertexAttribI3iv(const Context *context,
     92                              angle::EntryPoint entryPoint,
     93                              GLuint index,
     94                              const GLint *v);
     95 bool ValidateVertexAttribI3ui(const Context *context,
     96                              angle::EntryPoint entryPoint,
     97                              GLuint index,
     98                              GLuint x,
     99                              GLuint y,
    100                              GLuint z);
    101 bool ValidateVertexAttribI3uiv(const Context *context,
    102                               angle::EntryPoint entryPoint,
    103                               GLuint index,
    104                               const GLuint *v);
    105 bool ValidateVertexAttribI4bv(const Context *context,
    106                              angle::EntryPoint entryPoint,
    107                              GLuint index,
    108                              const GLbyte *v);
    109 bool ValidateVertexAttribI4sv(const Context *context,
    110                              angle::EntryPoint entryPoint,
    111                              GLuint index,
    112                              const GLshort *v);
    113 bool ValidateVertexAttribI4ubv(const Context *context,
    114                               angle::EntryPoint entryPoint,
    115                               GLuint index,
    116                               const GLubyte *v);
    117 bool ValidateVertexAttribI4usv(const Context *context,
    118                               angle::EntryPoint entryPoint,
    119                               GLuint index,
    120                               const GLushort *v);
    121 
    122 // GL 3.1
    123 bool ValidateGetActiveUniformName(const Context *context,
    124                                  angle::EntryPoint entryPoint,
    125                                  ShaderProgramID programPacked,
    126                                  GLuint uniformIndex,
    127                                  GLsizei bufSize,
    128                                  const GLsizei *length,
    129                                  const GLchar *uniformName);
    130 bool ValidatePrimitiveRestartIndex(const Context *context,
    131                                   angle::EntryPoint entryPoint,
    132                                   GLuint index);
    133 
    134 // GL 3.2
    135 bool ValidateMultiDrawElementsBaseVertex(const Context *context,
    136                                         angle::EntryPoint entryPoint,
    137                                         PrimitiveMode modePacked,
    138                                         const GLsizei *count,
    139                                         DrawElementsType typePacked,
    140                                         const void *const *indices,
    141                                         GLsizei drawcount,
    142                                         const GLint *basevertex);
    143 bool ValidateProvokingVertex(const Context *context,
    144                             angle::EntryPoint entryPoint,
    145                             ProvokingVertexConvention modePacked);
    146 bool ValidateTexImage2DMultisample(const Context *context,
    147                                   angle::EntryPoint entryPoint,
    148                                   GLenum target,
    149                                   GLsizei samples,
    150                                   GLenum internalformat,
    151                                   GLsizei width,
    152                                   GLsizei height,
    153                                   GLboolean fixedsamplelocations);
    154 bool ValidateTexImage3DMultisample(const Context *context,
    155                                   angle::EntryPoint entryPoint,
    156                                   GLenum target,
    157                                   GLsizei samples,
    158                                   GLenum internalformat,
    159                                   GLsizei width,
    160                                   GLsizei height,
    161                                   GLsizei depth,
    162                                   GLboolean fixedsamplelocations);
    163 
    164 // GL 3.3
    165 bool ValidateBindFragDataLocationIndexed(const Context *context,
    166                                         angle::EntryPoint entryPoint,
    167                                         ShaderProgramID programPacked,
    168                                         GLuint colorNumber,
    169                                         GLuint index,
    170                                         const GLchar *name);
    171 bool ValidateColorP3ui(const Context *context,
    172                       angle::EntryPoint entryPoint,
    173                       GLenum type,
    174                       GLuint color);
    175 bool ValidateColorP3uiv(const Context *context,
    176                        angle::EntryPoint entryPoint,
    177                        GLenum type,
    178                        const GLuint *color);
    179 bool ValidateColorP4ui(const Context *context,
    180                       angle::EntryPoint entryPoint,
    181                       GLenum type,
    182                       GLuint color);
    183 bool ValidateColorP4uiv(const Context *context,
    184                        angle::EntryPoint entryPoint,
    185                        GLenum type,
    186                        const GLuint *color);
    187 bool ValidateGetFragDataIndex(const Context *context,
    188                              angle::EntryPoint entryPoint,
    189                              ShaderProgramID programPacked,
    190                              const GLchar *name);
    191 bool ValidateGetQueryObjecti64v(const Context *context,
    192                                angle::EntryPoint entryPoint,
    193                                QueryID idPacked,
    194                                GLenum pname,
    195                                const GLint64 *params);
    196 bool ValidateGetQueryObjectui64v(const Context *context,
    197                                 angle::EntryPoint entryPoint,
    198                                 QueryID idPacked,
    199                                 GLenum pname,
    200                                 const GLuint64 *params);
    201 bool ValidateMultiTexCoordP1ui(const Context *context,
    202                               angle::EntryPoint entryPoint,
    203                               GLenum texture,
    204                               GLenum type,
    205                               GLuint coords);
    206 bool ValidateMultiTexCoordP1uiv(const Context *context,
    207                                angle::EntryPoint entryPoint,
    208                                GLenum texture,
    209                                GLenum type,
    210                                const GLuint *coords);
    211 bool ValidateMultiTexCoordP2ui(const Context *context,
    212                               angle::EntryPoint entryPoint,
    213                               GLenum texture,
    214                               GLenum type,
    215                               GLuint coords);
    216 bool ValidateMultiTexCoordP2uiv(const Context *context,
    217                                angle::EntryPoint entryPoint,
    218                                GLenum texture,
    219                                GLenum type,
    220                                const GLuint *coords);
    221 bool ValidateMultiTexCoordP3ui(const Context *context,
    222                               angle::EntryPoint entryPoint,
    223                               GLenum texture,
    224                               GLenum type,
    225                               GLuint coords);
    226 bool ValidateMultiTexCoordP3uiv(const Context *context,
    227                                angle::EntryPoint entryPoint,
    228                                GLenum texture,
    229                                GLenum type,
    230                                const GLuint *coords);
    231 bool ValidateMultiTexCoordP4ui(const Context *context,
    232                               angle::EntryPoint entryPoint,
    233                               GLenum texture,
    234                               GLenum type,
    235                               GLuint coords);
    236 bool ValidateMultiTexCoordP4uiv(const Context *context,
    237                                angle::EntryPoint entryPoint,
    238                                GLenum texture,
    239                                GLenum type,
    240                                const GLuint *coords);
    241 bool ValidateNormalP3ui(const Context *context,
    242                        angle::EntryPoint entryPoint,
    243                        GLenum type,
    244                        GLuint coords);
    245 bool ValidateNormalP3uiv(const Context *context,
    246                         angle::EntryPoint entryPoint,
    247                         GLenum type,
    248                         const GLuint *coords);
    249 bool ValidateQueryCounter(const Context *context,
    250                          angle::EntryPoint entryPoint,
    251                          QueryID idPacked,
    252                          QueryType targetPacked);
    253 bool ValidateSecondaryColorP3ui(const Context *context,
    254                                angle::EntryPoint entryPoint,
    255                                GLenum type,
    256                                GLuint color);
    257 bool ValidateSecondaryColorP3uiv(const Context *context,
    258                                 angle::EntryPoint entryPoint,
    259                                 GLenum type,
    260                                 const GLuint *color);
    261 bool ValidateTexCoordP1ui(const Context *context,
    262                          angle::EntryPoint entryPoint,
    263                          GLenum type,
    264                          GLuint coords);
    265 bool ValidateTexCoordP1uiv(const Context *context,
    266                           angle::EntryPoint entryPoint,
    267                           GLenum type,
    268                           const GLuint *coords);
    269 bool ValidateTexCoordP2ui(const Context *context,
    270                          angle::EntryPoint entryPoint,
    271                          GLenum type,
    272                          GLuint coords);
    273 bool ValidateTexCoordP2uiv(const Context *context,
    274                           angle::EntryPoint entryPoint,
    275                           GLenum type,
    276                           const GLuint *coords);
    277 bool ValidateTexCoordP3ui(const Context *context,
    278                          angle::EntryPoint entryPoint,
    279                          GLenum type,
    280                          GLuint coords);
    281 bool ValidateTexCoordP3uiv(const Context *context,
    282                           angle::EntryPoint entryPoint,
    283                           GLenum type,
    284                           const GLuint *coords);
    285 bool ValidateTexCoordP4ui(const Context *context,
    286                          angle::EntryPoint entryPoint,
    287                          GLenum type,
    288                          GLuint coords);
    289 bool ValidateTexCoordP4uiv(const Context *context,
    290                           angle::EntryPoint entryPoint,
    291                           GLenum type,
    292                           const GLuint *coords);
    293 bool ValidateVertexAttribP1ui(const Context *context,
    294                              angle::EntryPoint entryPoint,
    295                              GLuint index,
    296                              GLenum type,
    297                              GLboolean normalized,
    298                              GLuint value);
    299 bool ValidateVertexAttribP1uiv(const Context *context,
    300                               angle::EntryPoint entryPoint,
    301                               GLuint index,
    302                               GLenum type,
    303                               GLboolean normalized,
    304                               const GLuint *value);
    305 bool ValidateVertexAttribP2ui(const Context *context,
    306                              angle::EntryPoint entryPoint,
    307                              GLuint index,
    308                              GLenum type,
    309                              GLboolean normalized,
    310                              GLuint value);
    311 bool ValidateVertexAttribP2uiv(const Context *context,
    312                               angle::EntryPoint entryPoint,
    313                               GLuint index,
    314                               GLenum type,
    315                               GLboolean normalized,
    316                               const GLuint *value);
    317 bool ValidateVertexAttribP3ui(const Context *context,
    318                              angle::EntryPoint entryPoint,
    319                              GLuint index,
    320                              GLenum type,
    321                              GLboolean normalized,
    322                              GLuint value);
    323 bool ValidateVertexAttribP3uiv(const Context *context,
    324                               angle::EntryPoint entryPoint,
    325                               GLuint index,
    326                               GLenum type,
    327                               GLboolean normalized,
    328                               const GLuint *value);
    329 bool ValidateVertexAttribP4ui(const Context *context,
    330                              angle::EntryPoint entryPoint,
    331                              GLuint index,
    332                              GLenum type,
    333                              GLboolean normalized,
    334                              GLuint value);
    335 bool ValidateVertexAttribP4uiv(const Context *context,
    336                               angle::EntryPoint entryPoint,
    337                               GLuint index,
    338                               GLenum type,
    339                               GLboolean normalized,
    340                               const GLuint *value);
    341 bool ValidateVertexP2ui(const Context *context,
    342                        angle::EntryPoint entryPoint,
    343                        GLenum type,
    344                        GLuint value);
    345 bool ValidateVertexP2uiv(const Context *context,
    346                         angle::EntryPoint entryPoint,
    347                         GLenum type,
    348                         const GLuint *value);
    349 bool ValidateVertexP3ui(const Context *context,
    350                        angle::EntryPoint entryPoint,
    351                        GLenum type,
    352                        GLuint value);
    353 bool ValidateVertexP3uiv(const Context *context,
    354                         angle::EntryPoint entryPoint,
    355                         GLenum type,
    356                         const GLuint *value);
    357 bool ValidateVertexP4ui(const Context *context,
    358                        angle::EntryPoint entryPoint,
    359                        GLenum type,
    360                        GLuint value);
    361 bool ValidateVertexP4uiv(const Context *context,
    362                         angle::EntryPoint entryPoint,
    363                         GLenum type,
    364                         const GLuint *value);
    365 }  // namespace gl
    366 
    367 #endif  // LIBANGLE_VALIDATION_GL3_AUTOGEN_H_