tor-browser

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

validationES31.h (17516B)


      1 //
      2 // Copyright 2018 The ANGLE Project Authors. All rights reserved.
      3 // Use of this source code is governed by a BSD-style license that can be
      4 // found in the LICENSE file.
      5 //
      6 // validationES31.h:
      7 //  Inlined validation functions for OpenGL ES 3.1 entry points.
      8 
      9 #ifndef LIBANGLE_VALIDATION_ES31_H_
     10 #define LIBANGLE_VALIDATION_ES31_H_
     11 
     12 #include "libANGLE/ErrorStrings.h"
     13 #include "libANGLE/validationES31_autogen.h"
     14 
     15 namespace gl
     16 {
     17 
     18 bool ValidateTexBufferBase(const Context *context,
     19                           angle::EntryPoint entryPoint,
     20                           TextureType target,
     21                           GLenum internalformat,
     22                           BufferID bufferPacked);
     23 bool ValidateTexBufferRangeBase(const Context *context,
     24                                angle::EntryPoint entryPoint,
     25                                TextureType target,
     26                                GLenum internalformat,
     27                                BufferID bufferPacked,
     28                                GLintptr offset,
     29                                GLsizeiptr size);
     30 
     31 // GL_EXT_multi_draw_indirect
     32 bool ValidateMultiDrawIndirectBase(const Context *context,
     33                                   angle::EntryPoint entryPoint,
     34                                   GLsizei drawcount,
     35                                   GLsizei stride);
     36 
     37 // GL_EXT_separate_shader_objects
     38 bool ValidateActiveShaderProgramBase(const Context *context,
     39                                     angle::EntryPoint entryPoint,
     40                                     ProgramPipelineID pipelinePacked,
     41                                     ShaderProgramID programPacked);
     42 bool ValidateBindProgramPipelineBase(const Context *context,
     43                                     angle::EntryPoint entryPoint,
     44                                     ProgramPipelineID pipelinePacked);
     45 bool ValidateCreateShaderProgramvBase(const Context *context,
     46                                      angle::EntryPoint entryPoint,
     47                                      ShaderType typePacked,
     48                                      GLsizei count,
     49                                      const GLchar **strings);
     50 bool ValidateDeleteProgramPipelinesBase(const Context *context,
     51                                        angle::EntryPoint entryPoint,
     52                                        GLsizei n,
     53                                        const ProgramPipelineID *pipelinesPacked);
     54 bool ValidateGenProgramPipelinesBase(const Context *context,
     55                                     angle::EntryPoint entryPoint,
     56                                     GLsizei n,
     57                                     const ProgramPipelineID *pipelinesPacked);
     58 bool ValidateGetProgramPipelineInfoLogBase(const Context *context,
     59                                           angle::EntryPoint entryPoint,
     60                                           ProgramPipelineID pipelinePacked,
     61                                           GLsizei bufSize,
     62                                           const GLsizei *length,
     63                                           const GLchar *infoLog);
     64 bool ValidateGetProgramPipelineivBase(const Context *context,
     65                                      angle::EntryPoint entryPoint,
     66                                      ProgramPipelineID pipelinePacked,
     67                                      GLenum pname,
     68                                      const GLint *params);
     69 bool ValidateIsProgramPipelineBase(const Context *context,
     70                                   angle::EntryPoint entryPoint,
     71                                   ProgramPipelineID pipelinePacked);
     72 bool ValidateProgramParameteriBase(const Context *context,
     73                                   angle::EntryPoint entryPoint,
     74                                   ShaderProgramID programPacked,
     75                                   GLenum pname,
     76                                   GLint value);
     77 bool ValidateProgramUniform1fBase(const Context *context,
     78                                  angle::EntryPoint entryPoint,
     79                                  ShaderProgramID programPacked,
     80                                  UniformLocation locationPacked,
     81                                  GLfloat v0);
     82 bool ValidateProgramUniform1fvBase(const Context *context,
     83                                   angle::EntryPoint entryPoint,
     84                                   ShaderProgramID programPacked,
     85                                   UniformLocation locationPacked,
     86                                   GLsizei count,
     87                                   const GLfloat *value);
     88 bool ValidateProgramUniform1iBase(const Context *context,
     89                                  angle::EntryPoint entryPoint,
     90                                  ShaderProgramID programPacked,
     91                                  UniformLocation locationPacked,
     92                                  GLint v0);
     93 bool ValidateProgramUniform1ivBase(const Context *context,
     94                                   angle::EntryPoint entryPoint,
     95                                   ShaderProgramID programPacked,
     96                                   UniformLocation locationPacked,
     97                                   GLsizei count,
     98                                   const GLint *value);
     99 bool ValidateProgramUniform1uiBase(const Context *context,
    100                                   angle::EntryPoint entryPoint,
    101                                   ShaderProgramID programPacked,
    102                                   UniformLocation locationPacked,
    103                                   GLuint v0);
    104 bool ValidateProgramUniform1uivBase(const Context *context,
    105                                    angle::EntryPoint entryPoint,
    106                                    ShaderProgramID programPacked,
    107                                    UniformLocation locationPacked,
    108                                    GLsizei count,
    109                                    const GLuint *value);
    110 bool ValidateProgramUniform2fBase(const Context *context,
    111                                  angle::EntryPoint entryPoint,
    112                                  ShaderProgramID programPacked,
    113                                  UniformLocation locationPacked,
    114                                  GLfloat v0,
    115                                  GLfloat v1);
    116 bool ValidateProgramUniform2fvBase(const Context *context,
    117                                   angle::EntryPoint entryPoint,
    118                                   ShaderProgramID programPacked,
    119                                   UniformLocation locationPacked,
    120                                   GLsizei count,
    121                                   const GLfloat *value);
    122 bool ValidateProgramUniform2iBase(const Context *context,
    123                                  angle::EntryPoint entryPoint,
    124                                  ShaderProgramID programPacked,
    125                                  UniformLocation locationPacked,
    126                                  GLint v0,
    127                                  GLint v1);
    128 bool ValidateProgramUniform2ivBase(const Context *context,
    129                                   angle::EntryPoint entryPoint,
    130                                   ShaderProgramID programPacked,
    131                                   UniformLocation locationPacked,
    132                                   GLsizei count,
    133                                   const GLint *value);
    134 bool ValidateProgramUniform2uiBase(const Context *context,
    135                                   angle::EntryPoint entryPoint,
    136                                   ShaderProgramID programPacked,
    137                                   UniformLocation locationPacked,
    138                                   GLuint v0,
    139                                   GLuint v1);
    140 bool ValidateProgramUniform2uivBase(const Context *context,
    141                                    angle::EntryPoint entryPoint,
    142                                    ShaderProgramID programPacked,
    143                                    UniformLocation locationPacked,
    144                                    GLsizei count,
    145                                    const GLuint *value);
    146 bool ValidateProgramUniform3fBase(const Context *context,
    147                                  angle::EntryPoint entryPoint,
    148                                  ShaderProgramID programPacked,
    149                                  UniformLocation locationPacked,
    150                                  GLfloat v0,
    151                                  GLfloat v1,
    152                                  GLfloat v2);
    153 bool ValidateProgramUniform3fvBase(const Context *context,
    154                                   angle::EntryPoint entryPoint,
    155                                   ShaderProgramID programPacked,
    156                                   UniformLocation locationPacked,
    157                                   GLsizei count,
    158                                   const GLfloat *value);
    159 bool ValidateProgramUniform3iBase(const Context *context,
    160                                  angle::EntryPoint entryPoint,
    161                                  ShaderProgramID programPacked,
    162                                  UniformLocation locationPacked,
    163                                  GLint v0,
    164                                  GLint v1,
    165                                  GLint v2);
    166 bool ValidateProgramUniform3ivBase(const Context *context,
    167                                   angle::EntryPoint entryPoint,
    168                                   ShaderProgramID programPacked,
    169                                   UniformLocation locationPacked,
    170                                   GLsizei count,
    171                                   const GLint *value);
    172 bool ValidateProgramUniform3uiBase(const Context *context,
    173                                   angle::EntryPoint entryPoint,
    174                                   ShaderProgramID programPacked,
    175                                   UniformLocation locationPacked,
    176                                   GLuint v0,
    177                                   GLuint v1,
    178                                   GLuint v2);
    179 bool ValidateProgramUniform3uivBase(const Context *context,
    180                                    angle::EntryPoint entryPoint,
    181                                    ShaderProgramID programPacked,
    182                                    UniformLocation locationPacked,
    183                                    GLsizei count,
    184                                    const GLuint *value);
    185 bool ValidateProgramUniform4fBase(const Context *context,
    186                                  angle::EntryPoint entryPoint,
    187                                  ShaderProgramID programPacked,
    188                                  UniformLocation locationPacked,
    189                                  GLfloat v0,
    190                                  GLfloat v1,
    191                                  GLfloat v2,
    192                                  GLfloat v3);
    193 bool ValidateProgramUniform4fvBase(const Context *context,
    194                                   angle::EntryPoint entryPoint,
    195                                   ShaderProgramID programPacked,
    196                                   UniformLocation locationPacked,
    197                                   GLsizei count,
    198                                   const GLfloat *value);
    199 bool ValidateProgramUniform4iBase(const Context *context,
    200                                  angle::EntryPoint entryPoint,
    201                                  ShaderProgramID programPacked,
    202                                  UniformLocation locationPacked,
    203                                  GLint v0,
    204                                  GLint v1,
    205                                  GLint v2,
    206                                  GLint v3);
    207 bool ValidateProgramUniform4ivBase(const Context *context,
    208                                   angle::EntryPoint entryPoint,
    209                                   ShaderProgramID programPacked,
    210                                   UniformLocation locationPacked,
    211                                   GLsizei count,
    212                                   const GLint *value);
    213 bool ValidateProgramUniform4uiBase(const Context *context,
    214                                   angle::EntryPoint entryPoint,
    215                                   ShaderProgramID programPacked,
    216                                   UniformLocation locationPacked,
    217                                   GLuint v0,
    218                                   GLuint v1,
    219                                   GLuint v2,
    220                                   GLuint v3);
    221 bool ValidateProgramUniform4uivBase(const Context *context,
    222                                    angle::EntryPoint entryPoint,
    223                                    ShaderProgramID programPacked,
    224                                    UniformLocation locationPacked,
    225                                    GLsizei count,
    226                                    const GLuint *value);
    227 bool ValidateProgramUniformMatrix2fvBase(const Context *context,
    228                                         angle::EntryPoint entryPoint,
    229                                         ShaderProgramID programPacked,
    230                                         UniformLocation locationPacked,
    231                                         GLsizei count,
    232                                         GLboolean transpose,
    233                                         const GLfloat *value);
    234 bool ValidateProgramUniformMatrix2x3fvBase(const Context *context,
    235                                           angle::EntryPoint entryPoint,
    236                                           ShaderProgramID programPacked,
    237                                           UniformLocation locationPacked,
    238                                           GLsizei count,
    239                                           GLboolean transpose,
    240                                           const GLfloat *value);
    241 bool ValidateProgramUniformMatrix2x4fvBase(const Context *context,
    242                                           angle::EntryPoint entryPoint,
    243                                           ShaderProgramID programPacked,
    244                                           UniformLocation locationPacked,
    245                                           GLsizei count,
    246                                           GLboolean transpose,
    247                                           const GLfloat *value);
    248 bool ValidateProgramUniformMatrix3fvBase(const Context *context,
    249                                         angle::EntryPoint entryPoint,
    250                                         ShaderProgramID programPacked,
    251                                         UniformLocation locationPacked,
    252                                         GLsizei count,
    253                                         GLboolean transpose,
    254                                         const GLfloat *value);
    255 bool ValidateProgramUniformMatrix3x2fvBase(const Context *context,
    256                                           angle::EntryPoint entryPoint,
    257                                           ShaderProgramID programPacked,
    258                                           UniformLocation locationPacked,
    259                                           GLsizei count,
    260                                           GLboolean transpose,
    261                                           const GLfloat *value);
    262 bool ValidateProgramUniformMatrix3x4fvBase(const Context *context,
    263                                           angle::EntryPoint entryPoint,
    264                                           ShaderProgramID programPacked,
    265                                           UniformLocation locationPacked,
    266                                           GLsizei count,
    267                                           GLboolean transpose,
    268                                           const GLfloat *value);
    269 bool ValidateProgramUniformMatrix4fvBase(const Context *context,
    270                                         angle::EntryPoint entryPoint,
    271                                         ShaderProgramID programPacked,
    272                                         UniformLocation locationPacked,
    273                                         GLsizei count,
    274                                         GLboolean transpose,
    275                                         const GLfloat *value);
    276 bool ValidateProgramUniformMatrix4x2fvBase(const Context *context,
    277                                           angle::EntryPoint entryPoint,
    278                                           ShaderProgramID programPacked,
    279                                           UniformLocation locationPacked,
    280                                           GLsizei count,
    281                                           GLboolean transpose,
    282                                           const GLfloat *value);
    283 bool ValidateProgramUniformMatrix4x3fvBase(const Context *context,
    284                                           angle::EntryPoint entryPoint,
    285                                           ShaderProgramID programPacked,
    286                                           UniformLocation locationPacked,
    287                                           GLsizei count,
    288                                           GLboolean transpose,
    289                                           const GLfloat *value);
    290 bool ValidateUseProgramStagesBase(const Context *context,
    291                                  angle::EntryPoint entryPoint,
    292                                  ProgramPipelineID pipelinePacked,
    293                                  GLbitfield stages,
    294                                  ShaderProgramID programPacked);
    295 bool ValidateValidateProgramPipelineBase(const Context *context,
    296                                         angle::EntryPoint entryPoint,
    297                                         ProgramPipelineID pipelinePacked);
    298 }  // namespace gl
    299 
    300 #endif  // LIBANGLE_VALIDATION_ES31_H_