tor-browser

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

capture_gl_3_autogen.h (35091B)


      1 // GENERATED FILE - DO NOT EDIT.
      2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
      3 //
      4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
      5 // Use of this source code is governed by a BSD-style license that can be
      6 // found in the LICENSE file.
      7 //
      8 // capture_gl_3_autogen.h:
      9 //   Capture functions for the OpenGL ES Desktop GL 3.x entry points.
     10 
     11 #ifndef LIBANGLE_CAPTURE_GL_3_AUTOGEN_H_
     12 #define LIBANGLE_CAPTURE_GL_3_AUTOGEN_H_
     13 
     14 #include "common/PackedEnums.h"
     15 #include "libANGLE/capture/FrameCapture.h"
     16 
     17 namespace gl
     18 {
     19 
     20 // Method Captures
     21 
     22 // GL 3.0
     23 angle::CallCapture CaptureBeginConditionalRender(const State &glState,
     24                                                 bool isCallValid,
     25                                                 GLuint id,
     26                                                 GLenum mode);
     27 angle::CallCapture CaptureBindFragDataLocation(const State &glState,
     28                                               bool isCallValid,
     29                                               ShaderProgramID programPacked,
     30                                               GLuint color,
     31                                               const GLchar *name);
     32 angle::CallCapture CaptureClampColor(const State &glState,
     33                                     bool isCallValid,
     34                                     GLenum target,
     35                                     GLenum clamp);
     36 angle::CallCapture CaptureEndConditionalRender(const State &glState, bool isCallValid);
     37 angle::CallCapture CaptureFramebufferTexture1D(const State &glState,
     38                                               bool isCallValid,
     39                                               GLenum target,
     40                                               GLenum attachment,
     41                                               TextureTarget textargetPacked,
     42                                               TextureID texturePacked,
     43                                               GLint level);
     44 angle::CallCapture CaptureFramebufferTexture3D(const State &glState,
     45                                               bool isCallValid,
     46                                               GLenum target,
     47                                               GLenum attachment,
     48                                               TextureTarget textargetPacked,
     49                                               TextureID texturePacked,
     50                                               GLint level,
     51                                               GLint zoffset);
     52 angle::CallCapture CaptureVertexAttribI1i(const State &glState,
     53                                          bool isCallValid,
     54                                          GLuint index,
     55                                          GLint x);
     56 angle::CallCapture CaptureVertexAttribI1iv(const State &glState,
     57                                           bool isCallValid,
     58                                           GLuint index,
     59                                           const GLint *v);
     60 angle::CallCapture CaptureVertexAttribI1ui(const State &glState,
     61                                           bool isCallValid,
     62                                           GLuint index,
     63                                           GLuint x);
     64 angle::CallCapture CaptureVertexAttribI1uiv(const State &glState,
     65                                            bool isCallValid,
     66                                            GLuint index,
     67                                            const GLuint *v);
     68 angle::CallCapture CaptureVertexAttribI2i(const State &glState,
     69                                          bool isCallValid,
     70                                          GLuint index,
     71                                          GLint x,
     72                                          GLint y);
     73 angle::CallCapture CaptureVertexAttribI2iv(const State &glState,
     74                                           bool isCallValid,
     75                                           GLuint index,
     76                                           const GLint *v);
     77 angle::CallCapture CaptureVertexAttribI2ui(const State &glState,
     78                                           bool isCallValid,
     79                                           GLuint index,
     80                                           GLuint x,
     81                                           GLuint y);
     82 angle::CallCapture CaptureVertexAttribI2uiv(const State &glState,
     83                                            bool isCallValid,
     84                                            GLuint index,
     85                                            const GLuint *v);
     86 angle::CallCapture CaptureVertexAttribI3i(const State &glState,
     87                                          bool isCallValid,
     88                                          GLuint index,
     89                                          GLint x,
     90                                          GLint y,
     91                                          GLint z);
     92 angle::CallCapture CaptureVertexAttribI3iv(const State &glState,
     93                                           bool isCallValid,
     94                                           GLuint index,
     95                                           const GLint *v);
     96 angle::CallCapture CaptureVertexAttribI3ui(const State &glState,
     97                                           bool isCallValid,
     98                                           GLuint index,
     99                                           GLuint x,
    100                                           GLuint y,
    101                                           GLuint z);
    102 angle::CallCapture CaptureVertexAttribI3uiv(const State &glState,
    103                                            bool isCallValid,
    104                                            GLuint index,
    105                                            const GLuint *v);
    106 angle::CallCapture CaptureVertexAttribI4bv(const State &glState,
    107                                           bool isCallValid,
    108                                           GLuint index,
    109                                           const GLbyte *v);
    110 angle::CallCapture CaptureVertexAttribI4sv(const State &glState,
    111                                           bool isCallValid,
    112                                           GLuint index,
    113                                           const GLshort *v);
    114 angle::CallCapture CaptureVertexAttribI4ubv(const State &glState,
    115                                            bool isCallValid,
    116                                            GLuint index,
    117                                            const GLubyte *v);
    118 angle::CallCapture CaptureVertexAttribI4usv(const State &glState,
    119                                            bool isCallValid,
    120                                            GLuint index,
    121                                            const GLushort *v);
    122 
    123 // GL 3.1
    124 angle::CallCapture CaptureGetActiveUniformName(const State &glState,
    125                                               bool isCallValid,
    126                                               ShaderProgramID programPacked,
    127                                               GLuint uniformIndex,
    128                                               GLsizei bufSize,
    129                                               GLsizei *length,
    130                                               GLchar *uniformName);
    131 angle::CallCapture CapturePrimitiveRestartIndex(const State &glState,
    132                                                bool isCallValid,
    133                                                GLuint index);
    134 
    135 // GL 3.2
    136 angle::CallCapture CaptureMultiDrawElementsBaseVertex(const State &glState,
    137                                                      bool isCallValid,
    138                                                      PrimitiveMode modePacked,
    139                                                      const GLsizei *count,
    140                                                      DrawElementsType typePacked,
    141                                                      const void *const *indices,
    142                                                      GLsizei drawcount,
    143                                                      const GLint *basevertex);
    144 angle::CallCapture CaptureProvokingVertex(const State &glState,
    145                                          bool isCallValid,
    146                                          ProvokingVertexConvention modePacked);
    147 angle::CallCapture CaptureTexImage2DMultisample(const State &glState,
    148                                                bool isCallValid,
    149                                                GLenum target,
    150                                                GLsizei samples,
    151                                                GLenum internalformat,
    152                                                GLsizei width,
    153                                                GLsizei height,
    154                                                GLboolean fixedsamplelocations);
    155 angle::CallCapture CaptureTexImage3DMultisample(const State &glState,
    156                                                bool isCallValid,
    157                                                GLenum target,
    158                                                GLsizei samples,
    159                                                GLenum internalformat,
    160                                                GLsizei width,
    161                                                GLsizei height,
    162                                                GLsizei depth,
    163                                                GLboolean fixedsamplelocations);
    164 
    165 // GL 3.3
    166 angle::CallCapture CaptureBindFragDataLocationIndexed(const State &glState,
    167                                                      bool isCallValid,
    168                                                      ShaderProgramID programPacked,
    169                                                      GLuint colorNumber,
    170                                                      GLuint index,
    171                                                      const GLchar *name);
    172 angle::CallCapture CaptureColorP3ui(const State &glState,
    173                                    bool isCallValid,
    174                                    GLenum type,
    175                                    GLuint color);
    176 angle::CallCapture CaptureColorP3uiv(const State &glState,
    177                                     bool isCallValid,
    178                                     GLenum type,
    179                                     const GLuint *color);
    180 angle::CallCapture CaptureColorP4ui(const State &glState,
    181                                    bool isCallValid,
    182                                    GLenum type,
    183                                    GLuint color);
    184 angle::CallCapture CaptureColorP4uiv(const State &glState,
    185                                     bool isCallValid,
    186                                     GLenum type,
    187                                     const GLuint *color);
    188 angle::CallCapture CaptureGetFragDataIndex(const State &glState,
    189                                           bool isCallValid,
    190                                           ShaderProgramID programPacked,
    191                                           const GLchar *name,
    192                                           GLint returnValue);
    193 angle::CallCapture CaptureGetQueryObjecti64v(const State &glState,
    194                                             bool isCallValid,
    195                                             QueryID idPacked,
    196                                             GLenum pname,
    197                                             GLint64 *params);
    198 angle::CallCapture CaptureGetQueryObjectui64v(const State &glState,
    199                                              bool isCallValid,
    200                                              QueryID idPacked,
    201                                              GLenum pname,
    202                                              GLuint64 *params);
    203 angle::CallCapture CaptureMultiTexCoordP1ui(const State &glState,
    204                                            bool isCallValid,
    205                                            GLenum texture,
    206                                            GLenum type,
    207                                            GLuint coords);
    208 angle::CallCapture CaptureMultiTexCoordP1uiv(const State &glState,
    209                                             bool isCallValid,
    210                                             GLenum texture,
    211                                             GLenum type,
    212                                             const GLuint *coords);
    213 angle::CallCapture CaptureMultiTexCoordP2ui(const State &glState,
    214                                            bool isCallValid,
    215                                            GLenum texture,
    216                                            GLenum type,
    217                                            GLuint coords);
    218 angle::CallCapture CaptureMultiTexCoordP2uiv(const State &glState,
    219                                             bool isCallValid,
    220                                             GLenum texture,
    221                                             GLenum type,
    222                                             const GLuint *coords);
    223 angle::CallCapture CaptureMultiTexCoordP3ui(const State &glState,
    224                                            bool isCallValid,
    225                                            GLenum texture,
    226                                            GLenum type,
    227                                            GLuint coords);
    228 angle::CallCapture CaptureMultiTexCoordP3uiv(const State &glState,
    229                                             bool isCallValid,
    230                                             GLenum texture,
    231                                             GLenum type,
    232                                             const GLuint *coords);
    233 angle::CallCapture CaptureMultiTexCoordP4ui(const State &glState,
    234                                            bool isCallValid,
    235                                            GLenum texture,
    236                                            GLenum type,
    237                                            GLuint coords);
    238 angle::CallCapture CaptureMultiTexCoordP4uiv(const State &glState,
    239                                             bool isCallValid,
    240                                             GLenum texture,
    241                                             GLenum type,
    242                                             const GLuint *coords);
    243 angle::CallCapture CaptureNormalP3ui(const State &glState,
    244                                     bool isCallValid,
    245                                     GLenum type,
    246                                     GLuint coords);
    247 angle::CallCapture CaptureNormalP3uiv(const State &glState,
    248                                      bool isCallValid,
    249                                      GLenum type,
    250                                      const GLuint *coords);
    251 angle::CallCapture CaptureQueryCounter(const State &glState,
    252                                       bool isCallValid,
    253                                       QueryID idPacked,
    254                                       QueryType targetPacked);
    255 angle::CallCapture CaptureSecondaryColorP3ui(const State &glState,
    256                                             bool isCallValid,
    257                                             GLenum type,
    258                                             GLuint color);
    259 angle::CallCapture CaptureSecondaryColorP3uiv(const State &glState,
    260                                              bool isCallValid,
    261                                              GLenum type,
    262                                              const GLuint *color);
    263 angle::CallCapture CaptureTexCoordP1ui(const State &glState,
    264                                       bool isCallValid,
    265                                       GLenum type,
    266                                       GLuint coords);
    267 angle::CallCapture CaptureTexCoordP1uiv(const State &glState,
    268                                        bool isCallValid,
    269                                        GLenum type,
    270                                        const GLuint *coords);
    271 angle::CallCapture CaptureTexCoordP2ui(const State &glState,
    272                                       bool isCallValid,
    273                                       GLenum type,
    274                                       GLuint coords);
    275 angle::CallCapture CaptureTexCoordP2uiv(const State &glState,
    276                                        bool isCallValid,
    277                                        GLenum type,
    278                                        const GLuint *coords);
    279 angle::CallCapture CaptureTexCoordP3ui(const State &glState,
    280                                       bool isCallValid,
    281                                       GLenum type,
    282                                       GLuint coords);
    283 angle::CallCapture CaptureTexCoordP3uiv(const State &glState,
    284                                        bool isCallValid,
    285                                        GLenum type,
    286                                        const GLuint *coords);
    287 angle::CallCapture CaptureTexCoordP4ui(const State &glState,
    288                                       bool isCallValid,
    289                                       GLenum type,
    290                                       GLuint coords);
    291 angle::CallCapture CaptureTexCoordP4uiv(const State &glState,
    292                                        bool isCallValid,
    293                                        GLenum type,
    294                                        const GLuint *coords);
    295 angle::CallCapture CaptureVertexAttribP1ui(const State &glState,
    296                                           bool isCallValid,
    297                                           GLuint index,
    298                                           GLenum type,
    299                                           GLboolean normalized,
    300                                           GLuint value);
    301 angle::CallCapture CaptureVertexAttribP1uiv(const State &glState,
    302                                            bool isCallValid,
    303                                            GLuint index,
    304                                            GLenum type,
    305                                            GLboolean normalized,
    306                                            const GLuint *value);
    307 angle::CallCapture CaptureVertexAttribP2ui(const State &glState,
    308                                           bool isCallValid,
    309                                           GLuint index,
    310                                           GLenum type,
    311                                           GLboolean normalized,
    312                                           GLuint value);
    313 angle::CallCapture CaptureVertexAttribP2uiv(const State &glState,
    314                                            bool isCallValid,
    315                                            GLuint index,
    316                                            GLenum type,
    317                                            GLboolean normalized,
    318                                            const GLuint *value);
    319 angle::CallCapture CaptureVertexAttribP3ui(const State &glState,
    320                                           bool isCallValid,
    321                                           GLuint index,
    322                                           GLenum type,
    323                                           GLboolean normalized,
    324                                           GLuint value);
    325 angle::CallCapture CaptureVertexAttribP3uiv(const State &glState,
    326                                            bool isCallValid,
    327                                            GLuint index,
    328                                            GLenum type,
    329                                            GLboolean normalized,
    330                                            const GLuint *value);
    331 angle::CallCapture CaptureVertexAttribP4ui(const State &glState,
    332                                           bool isCallValid,
    333                                           GLuint index,
    334                                           GLenum type,
    335                                           GLboolean normalized,
    336                                           GLuint value);
    337 angle::CallCapture CaptureVertexAttribP4uiv(const State &glState,
    338                                            bool isCallValid,
    339                                            GLuint index,
    340                                            GLenum type,
    341                                            GLboolean normalized,
    342                                            const GLuint *value);
    343 angle::CallCapture CaptureVertexP2ui(const State &glState,
    344                                     bool isCallValid,
    345                                     GLenum type,
    346                                     GLuint value);
    347 angle::CallCapture CaptureVertexP2uiv(const State &glState,
    348                                      bool isCallValid,
    349                                      GLenum type,
    350                                      const GLuint *value);
    351 angle::CallCapture CaptureVertexP3ui(const State &glState,
    352                                     bool isCallValid,
    353                                     GLenum type,
    354                                     GLuint value);
    355 angle::CallCapture CaptureVertexP3uiv(const State &glState,
    356                                      bool isCallValid,
    357                                      GLenum type,
    358                                      const GLuint *value);
    359 angle::CallCapture CaptureVertexP4ui(const State &glState,
    360                                     bool isCallValid,
    361                                     GLenum type,
    362                                     GLuint value);
    363 angle::CallCapture CaptureVertexP4uiv(const State &glState,
    364                                      bool isCallValid,
    365                                      GLenum type,
    366                                      const GLuint *value);
    367 
    368 // Parameter Captures
    369 
    370 // GL 3.0
    371 void CaptureBindFragDataLocation_name(const State &glState,
    372                                      bool isCallValid,
    373                                      ShaderProgramID programPacked,
    374                                      GLuint color,
    375                                      const GLchar *name,
    376                                      angle::ParamCapture *paramCapture);
    377 void CaptureVertexAttribI1iv_v(const State &glState,
    378                               bool isCallValid,
    379                               GLuint index,
    380                               const GLint *v,
    381                               angle::ParamCapture *paramCapture);
    382 void CaptureVertexAttribI1uiv_v(const State &glState,
    383                                bool isCallValid,
    384                                GLuint index,
    385                                const GLuint *v,
    386                                angle::ParamCapture *paramCapture);
    387 void CaptureVertexAttribI2iv_v(const State &glState,
    388                               bool isCallValid,
    389                               GLuint index,
    390                               const GLint *v,
    391                               angle::ParamCapture *paramCapture);
    392 void CaptureVertexAttribI2uiv_v(const State &glState,
    393                                bool isCallValid,
    394                                GLuint index,
    395                                const GLuint *v,
    396                                angle::ParamCapture *paramCapture);
    397 void CaptureVertexAttribI3iv_v(const State &glState,
    398                               bool isCallValid,
    399                               GLuint index,
    400                               const GLint *v,
    401                               angle::ParamCapture *paramCapture);
    402 void CaptureVertexAttribI3uiv_v(const State &glState,
    403                                bool isCallValid,
    404                                GLuint index,
    405                                const GLuint *v,
    406                                angle::ParamCapture *paramCapture);
    407 void CaptureVertexAttribI4bv_v(const State &glState,
    408                               bool isCallValid,
    409                               GLuint index,
    410                               const GLbyte *v,
    411                               angle::ParamCapture *paramCapture);
    412 void CaptureVertexAttribI4sv_v(const State &glState,
    413                               bool isCallValid,
    414                               GLuint index,
    415                               const GLshort *v,
    416                               angle::ParamCapture *paramCapture);
    417 void CaptureVertexAttribI4ubv_v(const State &glState,
    418                                bool isCallValid,
    419                                GLuint index,
    420                                const GLubyte *v,
    421                                angle::ParamCapture *paramCapture);
    422 void CaptureVertexAttribI4usv_v(const State &glState,
    423                                bool isCallValid,
    424                                GLuint index,
    425                                const GLushort *v,
    426                                angle::ParamCapture *paramCapture);
    427 
    428 // GL 3.1
    429 void CaptureGetActiveUniformName_length(const State &glState,
    430                                        bool isCallValid,
    431                                        ShaderProgramID programPacked,
    432                                        GLuint uniformIndex,
    433                                        GLsizei bufSize,
    434                                        GLsizei *length,
    435                                        GLchar *uniformName,
    436                                        angle::ParamCapture *paramCapture);
    437 void CaptureGetActiveUniformName_uniformName(const State &glState,
    438                                             bool isCallValid,
    439                                             ShaderProgramID programPacked,
    440                                             GLuint uniformIndex,
    441                                             GLsizei bufSize,
    442                                             GLsizei *length,
    443                                             GLchar *uniformName,
    444                                             angle::ParamCapture *paramCapture);
    445 
    446 // GL 3.2
    447 void CaptureMultiDrawElementsBaseVertex_count(const State &glState,
    448                                              bool isCallValid,
    449                                              PrimitiveMode modePacked,
    450                                              const GLsizei *count,
    451                                              DrawElementsType typePacked,
    452                                              const void *const *indices,
    453                                              GLsizei drawcount,
    454                                              const GLint *basevertex,
    455                                              angle::ParamCapture *paramCapture);
    456 void CaptureMultiDrawElementsBaseVertex_indices(const State &glState,
    457                                                bool isCallValid,
    458                                                PrimitiveMode modePacked,
    459                                                const GLsizei *count,
    460                                                DrawElementsType typePacked,
    461                                                const void *const *indices,
    462                                                GLsizei drawcount,
    463                                                const GLint *basevertex,
    464                                                angle::ParamCapture *paramCapture);
    465 void CaptureMultiDrawElementsBaseVertex_basevertex(const State &glState,
    466                                                   bool isCallValid,
    467                                                   PrimitiveMode modePacked,
    468                                                   const GLsizei *count,
    469                                                   DrawElementsType typePacked,
    470                                                   const void *const *indices,
    471                                                   GLsizei drawcount,
    472                                                   const GLint *basevertex,
    473                                                   angle::ParamCapture *paramCapture);
    474 
    475 // GL 3.3
    476 void CaptureBindFragDataLocationIndexed_name(const State &glState,
    477                                             bool isCallValid,
    478                                             ShaderProgramID programPacked,
    479                                             GLuint colorNumber,
    480                                             GLuint index,
    481                                             const GLchar *name,
    482                                             angle::ParamCapture *paramCapture);
    483 void CaptureColorP3uiv_color(const State &glState,
    484                             bool isCallValid,
    485                             GLenum type,
    486                             const GLuint *color,
    487                             angle::ParamCapture *paramCapture);
    488 void CaptureColorP4uiv_color(const State &glState,
    489                             bool isCallValid,
    490                             GLenum type,
    491                             const GLuint *color,
    492                             angle::ParamCapture *paramCapture);
    493 void CaptureGetFragDataIndex_name(const State &glState,
    494                                  bool isCallValid,
    495                                  ShaderProgramID programPacked,
    496                                  const GLchar *name,
    497                                  angle::ParamCapture *paramCapture);
    498 void CaptureGetQueryObjecti64v_params(const State &glState,
    499                                      bool isCallValid,
    500                                      QueryID idPacked,
    501                                      GLenum pname,
    502                                      GLint64 *params,
    503                                      angle::ParamCapture *paramCapture);
    504 void CaptureGetQueryObjectui64v_params(const State &glState,
    505                                       bool isCallValid,
    506                                       QueryID idPacked,
    507                                       GLenum pname,
    508                                       GLuint64 *params,
    509                                       angle::ParamCapture *paramCapture);
    510 void CaptureMultiTexCoordP1uiv_coords(const State &glState,
    511                                      bool isCallValid,
    512                                      GLenum texture,
    513                                      GLenum type,
    514                                      const GLuint *coords,
    515                                      angle::ParamCapture *paramCapture);
    516 void CaptureMultiTexCoordP2uiv_coords(const State &glState,
    517                                      bool isCallValid,
    518                                      GLenum texture,
    519                                      GLenum type,
    520                                      const GLuint *coords,
    521                                      angle::ParamCapture *paramCapture);
    522 void CaptureMultiTexCoordP3uiv_coords(const State &glState,
    523                                      bool isCallValid,
    524                                      GLenum texture,
    525                                      GLenum type,
    526                                      const GLuint *coords,
    527                                      angle::ParamCapture *paramCapture);
    528 void CaptureMultiTexCoordP4uiv_coords(const State &glState,
    529                                      bool isCallValid,
    530                                      GLenum texture,
    531                                      GLenum type,
    532                                      const GLuint *coords,
    533                                      angle::ParamCapture *paramCapture);
    534 void CaptureNormalP3uiv_coords(const State &glState,
    535                               bool isCallValid,
    536                               GLenum type,
    537                               const GLuint *coords,
    538                               angle::ParamCapture *paramCapture);
    539 void CaptureSecondaryColorP3uiv_color(const State &glState,
    540                                      bool isCallValid,
    541                                      GLenum type,
    542                                      const GLuint *color,
    543                                      angle::ParamCapture *paramCapture);
    544 void CaptureTexCoordP1uiv_coords(const State &glState,
    545                                 bool isCallValid,
    546                                 GLenum type,
    547                                 const GLuint *coords,
    548                                 angle::ParamCapture *paramCapture);
    549 void CaptureTexCoordP2uiv_coords(const State &glState,
    550                                 bool isCallValid,
    551                                 GLenum type,
    552                                 const GLuint *coords,
    553                                 angle::ParamCapture *paramCapture);
    554 void CaptureTexCoordP3uiv_coords(const State &glState,
    555                                 bool isCallValid,
    556                                 GLenum type,
    557                                 const GLuint *coords,
    558                                 angle::ParamCapture *paramCapture);
    559 void CaptureTexCoordP4uiv_coords(const State &glState,
    560                                 bool isCallValid,
    561                                 GLenum type,
    562                                 const GLuint *coords,
    563                                 angle::ParamCapture *paramCapture);
    564 void CaptureVertexAttribP1uiv_value(const State &glState,
    565                                    bool isCallValid,
    566                                    GLuint index,
    567                                    GLenum type,
    568                                    GLboolean normalized,
    569                                    const GLuint *value,
    570                                    angle::ParamCapture *paramCapture);
    571 void CaptureVertexAttribP2uiv_value(const State &glState,
    572                                    bool isCallValid,
    573                                    GLuint index,
    574                                    GLenum type,
    575                                    GLboolean normalized,
    576                                    const GLuint *value,
    577                                    angle::ParamCapture *paramCapture);
    578 void CaptureVertexAttribP3uiv_value(const State &glState,
    579                                    bool isCallValid,
    580                                    GLuint index,
    581                                    GLenum type,
    582                                    GLboolean normalized,
    583                                    const GLuint *value,
    584                                    angle::ParamCapture *paramCapture);
    585 void CaptureVertexAttribP4uiv_value(const State &glState,
    586                                    bool isCallValid,
    587                                    GLuint index,
    588                                    GLenum type,
    589                                    GLboolean normalized,
    590                                    const GLuint *value,
    591                                    angle::ParamCapture *paramCapture);
    592 void CaptureVertexP2uiv_value(const State &glState,
    593                              bool isCallValid,
    594                              GLenum type,
    595                              const GLuint *value,
    596                              angle::ParamCapture *paramCapture);
    597 void CaptureVertexP3uiv_value(const State &glState,
    598                              bool isCallValid,
    599                              GLenum type,
    600                              const GLuint *value,
    601                              angle::ParamCapture *paramCapture);
    602 void CaptureVertexP4uiv_value(const State &glState,
    603                              bool isCallValid,
    604                              GLenum type,
    605                              const GLuint *value,
    606                              angle::ParamCapture *paramCapture);
    607 }  // namespace gl
    608 
    609 #endif  // LIBANGLE_CAPTURE_GL_3_AUTOGEN_H_