tor-browser

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

capture_gles_1_0_autogen.h (32049B)


      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_gles_1_0_autogen.h:
      9 //   Capture functions for the OpenGL ES 1.0 entry points.
     10 
     11 #ifndef LIBANGLE_CAPTURE_GLES_1_0_AUTOGEN_H_
     12 #define LIBANGLE_CAPTURE_GLES_1_0_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 angle::CallCapture CaptureAlphaFunc(const State &glState,
     23                                    bool isCallValid,
     24                                    AlphaTestFunc funcPacked,
     25                                    GLfloat ref);
     26 angle::CallCapture CaptureAlphaFuncx(const State &glState,
     27                                     bool isCallValid,
     28                                     AlphaTestFunc funcPacked,
     29                                     GLfixed ref);
     30 angle::CallCapture CaptureClearColorx(const State &glState,
     31                                      bool isCallValid,
     32                                      GLfixed red,
     33                                      GLfixed green,
     34                                      GLfixed blue,
     35                                      GLfixed alpha);
     36 angle::CallCapture CaptureClearDepthx(const State &glState, bool isCallValid, GLfixed depth);
     37 angle::CallCapture CaptureClientActiveTexture(const State &glState,
     38                                              bool isCallValid,
     39                                              GLenum texture);
     40 angle::CallCapture CaptureClipPlanef(const State &glState,
     41                                     bool isCallValid,
     42                                     GLenum p,
     43                                     const GLfloat *eqn);
     44 angle::CallCapture CaptureClipPlanex(const State &glState,
     45                                     bool isCallValid,
     46                                     GLenum plane,
     47                                     const GLfixed *equation);
     48 angle::CallCapture CaptureColor4f(const State &glState,
     49                                  bool isCallValid,
     50                                  GLfloat red,
     51                                  GLfloat green,
     52                                  GLfloat blue,
     53                                  GLfloat alpha);
     54 angle::CallCapture CaptureColor4ub(const State &glState,
     55                                   bool isCallValid,
     56                                   GLubyte red,
     57                                   GLubyte green,
     58                                   GLubyte blue,
     59                                   GLubyte alpha);
     60 angle::CallCapture CaptureColor4x(const State &glState,
     61                                  bool isCallValid,
     62                                  GLfixed red,
     63                                  GLfixed green,
     64                                  GLfixed blue,
     65                                  GLfixed alpha);
     66 angle::CallCapture CaptureColorPointer(const State &glState,
     67                                       bool isCallValid,
     68                                       GLint size,
     69                                       VertexAttribType typePacked,
     70                                       GLsizei stride,
     71                                       const void *pointer);
     72 angle::CallCapture CaptureDepthRangex(const State &glState, bool isCallValid, GLfixed n, GLfixed f);
     73 angle::CallCapture CaptureDisableClientState(const State &glState,
     74                                             bool isCallValid,
     75                                             ClientVertexArrayType arrayPacked);
     76 angle::CallCapture CaptureEnableClientState(const State &glState,
     77                                            bool isCallValid,
     78                                            ClientVertexArrayType arrayPacked);
     79 angle::CallCapture CaptureFogf(const State &glState, bool isCallValid, GLenum pname, GLfloat param);
     80 angle::CallCapture CaptureFogfv(const State &glState,
     81                                bool isCallValid,
     82                                GLenum pname,
     83                                const GLfloat *params);
     84 angle::CallCapture CaptureFogx(const State &glState, bool isCallValid, GLenum pname, GLfixed param);
     85 angle::CallCapture CaptureFogxv(const State &glState,
     86                                bool isCallValid,
     87                                GLenum pname,
     88                                const GLfixed *param);
     89 angle::CallCapture CaptureFrustumf(const State &glState,
     90                                   bool isCallValid,
     91                                   GLfloat l,
     92                                   GLfloat r,
     93                                   GLfloat b,
     94                                   GLfloat t,
     95                                   GLfloat n,
     96                                   GLfloat f);
     97 angle::CallCapture CaptureFrustumx(const State &glState,
     98                                   bool isCallValid,
     99                                   GLfixed l,
    100                                   GLfixed r,
    101                                   GLfixed b,
    102                                   GLfixed t,
    103                                   GLfixed n,
    104                                   GLfixed f);
    105 angle::CallCapture CaptureGetClipPlanef(const State &glState,
    106                                        bool isCallValid,
    107                                        GLenum plane,
    108                                        GLfloat *equation);
    109 angle::CallCapture CaptureGetClipPlanex(const State &glState,
    110                                        bool isCallValid,
    111                                        GLenum plane,
    112                                        GLfixed *equation);
    113 angle::CallCapture CaptureGetFixedv(const State &glState,
    114                                    bool isCallValid,
    115                                    GLenum pname,
    116                                    GLfixed *params);
    117 angle::CallCapture CaptureGetLightfv(const State &glState,
    118                                     bool isCallValid,
    119                                     GLenum light,
    120                                     LightParameter pnamePacked,
    121                                     GLfloat *params);
    122 angle::CallCapture CaptureGetLightxv(const State &glState,
    123                                     bool isCallValid,
    124                                     GLenum light,
    125                                     LightParameter pnamePacked,
    126                                     GLfixed *params);
    127 angle::CallCapture CaptureGetMaterialfv(const State &glState,
    128                                        bool isCallValid,
    129                                        GLenum face,
    130                                        MaterialParameter pnamePacked,
    131                                        GLfloat *params);
    132 angle::CallCapture CaptureGetMaterialxv(const State &glState,
    133                                        bool isCallValid,
    134                                        GLenum face,
    135                                        MaterialParameter pnamePacked,
    136                                        GLfixed *params);
    137 angle::CallCapture CaptureGetTexEnvfv(const State &glState,
    138                                      bool isCallValid,
    139                                      TextureEnvTarget targetPacked,
    140                                      TextureEnvParameter pnamePacked,
    141                                      GLfloat *params);
    142 angle::CallCapture CaptureGetTexEnviv(const State &glState,
    143                                      bool isCallValid,
    144                                      TextureEnvTarget targetPacked,
    145                                      TextureEnvParameter pnamePacked,
    146                                      GLint *params);
    147 angle::CallCapture CaptureGetTexEnvxv(const State &glState,
    148                                      bool isCallValid,
    149                                      TextureEnvTarget targetPacked,
    150                                      TextureEnvParameter pnamePacked,
    151                                      GLfixed *params);
    152 angle::CallCapture CaptureGetTexParameterxv(const State &glState,
    153                                            bool isCallValid,
    154                                            TextureType targetPacked,
    155                                            GLenum pname,
    156                                            GLfixed *params);
    157 angle::CallCapture CaptureLightModelf(const State &glState,
    158                                      bool isCallValid,
    159                                      GLenum pname,
    160                                      GLfloat param);
    161 angle::CallCapture CaptureLightModelfv(const State &glState,
    162                                       bool isCallValid,
    163                                       GLenum pname,
    164                                       const GLfloat *params);
    165 angle::CallCapture CaptureLightModelx(const State &glState,
    166                                      bool isCallValid,
    167                                      GLenum pname,
    168                                      GLfixed param);
    169 angle::CallCapture CaptureLightModelxv(const State &glState,
    170                                       bool isCallValid,
    171                                       GLenum pname,
    172                                       const GLfixed *param);
    173 angle::CallCapture CaptureLightf(const State &glState,
    174                                 bool isCallValid,
    175                                 GLenum light,
    176                                 LightParameter pnamePacked,
    177                                 GLfloat param);
    178 angle::CallCapture CaptureLightfv(const State &glState,
    179                                  bool isCallValid,
    180                                  GLenum light,
    181                                  LightParameter pnamePacked,
    182                                  const GLfloat *params);
    183 angle::CallCapture CaptureLightx(const State &glState,
    184                                 bool isCallValid,
    185                                 GLenum light,
    186                                 LightParameter pnamePacked,
    187                                 GLfixed param);
    188 angle::CallCapture CaptureLightxv(const State &glState,
    189                                  bool isCallValid,
    190                                  GLenum light,
    191                                  LightParameter pnamePacked,
    192                                  const GLfixed *params);
    193 angle::CallCapture CaptureLineWidthx(const State &glState, bool isCallValid, GLfixed width);
    194 angle::CallCapture CaptureLoadIdentity(const State &glState, bool isCallValid);
    195 angle::CallCapture CaptureLoadMatrixf(const State &glState, bool isCallValid, const GLfloat *m);
    196 angle::CallCapture CaptureLoadMatrixx(const State &glState, bool isCallValid, const GLfixed *m);
    197 angle::CallCapture CaptureLogicOp(const State &glState,
    198                                  bool isCallValid,
    199                                  LogicalOperation opcodePacked);
    200 angle::CallCapture CaptureMaterialf(const State &glState,
    201                                    bool isCallValid,
    202                                    GLenum face,
    203                                    MaterialParameter pnamePacked,
    204                                    GLfloat param);
    205 angle::CallCapture CaptureMaterialfv(const State &glState,
    206                                     bool isCallValid,
    207                                     GLenum face,
    208                                     MaterialParameter pnamePacked,
    209                                     const GLfloat *params);
    210 angle::CallCapture CaptureMaterialx(const State &glState,
    211                                    bool isCallValid,
    212                                    GLenum face,
    213                                    MaterialParameter pnamePacked,
    214                                    GLfixed param);
    215 angle::CallCapture CaptureMaterialxv(const State &glState,
    216                                     bool isCallValid,
    217                                     GLenum face,
    218                                     MaterialParameter pnamePacked,
    219                                     const GLfixed *param);
    220 angle::CallCapture CaptureMatrixMode(const State &glState, bool isCallValid, MatrixType modePacked);
    221 angle::CallCapture CaptureMultMatrixf(const State &glState, bool isCallValid, const GLfloat *m);
    222 angle::CallCapture CaptureMultMatrixx(const State &glState, bool isCallValid, const GLfixed *m);
    223 angle::CallCapture CaptureMultiTexCoord4f(const State &glState,
    224                                          bool isCallValid,
    225                                          GLenum target,
    226                                          GLfloat s,
    227                                          GLfloat t,
    228                                          GLfloat r,
    229                                          GLfloat q);
    230 angle::CallCapture CaptureMultiTexCoord4x(const State &glState,
    231                                          bool isCallValid,
    232                                          GLenum texture,
    233                                          GLfixed s,
    234                                          GLfixed t,
    235                                          GLfixed r,
    236                                          GLfixed q);
    237 angle::CallCapture CaptureNormal3f(const State &glState,
    238                                   bool isCallValid,
    239                                   GLfloat nx,
    240                                   GLfloat ny,
    241                                   GLfloat nz);
    242 angle::CallCapture CaptureNormal3x(const State &glState,
    243                                   bool isCallValid,
    244                                   GLfixed nx,
    245                                   GLfixed ny,
    246                                   GLfixed nz);
    247 angle::CallCapture CaptureNormalPointer(const State &glState,
    248                                        bool isCallValid,
    249                                        VertexAttribType typePacked,
    250                                        GLsizei stride,
    251                                        const void *pointer);
    252 angle::CallCapture CaptureOrthof(const State &glState,
    253                                 bool isCallValid,
    254                                 GLfloat l,
    255                                 GLfloat r,
    256                                 GLfloat b,
    257                                 GLfloat t,
    258                                 GLfloat n,
    259                                 GLfloat f);
    260 angle::CallCapture CaptureOrthox(const State &glState,
    261                                 bool isCallValid,
    262                                 GLfixed l,
    263                                 GLfixed r,
    264                                 GLfixed b,
    265                                 GLfixed t,
    266                                 GLfixed n,
    267                                 GLfixed f);
    268 angle::CallCapture CapturePointParameterf(const State &glState,
    269                                          bool isCallValid,
    270                                          PointParameter pnamePacked,
    271                                          GLfloat param);
    272 angle::CallCapture CapturePointParameterfv(const State &glState,
    273                                           bool isCallValid,
    274                                           PointParameter pnamePacked,
    275                                           const GLfloat *params);
    276 angle::CallCapture CapturePointParameterx(const State &glState,
    277                                          bool isCallValid,
    278                                          PointParameter pnamePacked,
    279                                          GLfixed param);
    280 angle::CallCapture CapturePointParameterxv(const State &glState,
    281                                           bool isCallValid,
    282                                           PointParameter pnamePacked,
    283                                           const GLfixed *params);
    284 angle::CallCapture CapturePointSize(const State &glState, bool isCallValid, GLfloat size);
    285 angle::CallCapture CapturePointSizex(const State &glState, bool isCallValid, GLfixed size);
    286 angle::CallCapture CapturePolygonOffsetx(const State &glState,
    287                                         bool isCallValid,
    288                                         GLfixed factor,
    289                                         GLfixed units);
    290 angle::CallCapture CapturePopMatrix(const State &glState, bool isCallValid);
    291 angle::CallCapture CapturePushMatrix(const State &glState, bool isCallValid);
    292 angle::CallCapture CaptureRotatef(const State &glState,
    293                                  bool isCallValid,
    294                                  GLfloat angle,
    295                                  GLfloat x,
    296                                  GLfloat y,
    297                                  GLfloat z);
    298 angle::CallCapture CaptureRotatex(const State &glState,
    299                                  bool isCallValid,
    300                                  GLfixed angle,
    301                                  GLfixed x,
    302                                  GLfixed y,
    303                                  GLfixed z);
    304 angle::CallCapture CaptureSampleCoveragex(const State &glState,
    305                                          bool isCallValid,
    306                                          GLclampx value,
    307                                          GLboolean invert);
    308 angle::CallCapture CaptureScalef(const State &glState,
    309                                 bool isCallValid,
    310                                 GLfloat x,
    311                                 GLfloat y,
    312                                 GLfloat z);
    313 angle::CallCapture CaptureScalex(const State &glState,
    314                                 bool isCallValid,
    315                                 GLfixed x,
    316                                 GLfixed y,
    317                                 GLfixed z);
    318 angle::CallCapture CaptureShadeModel(const State &glState,
    319                                     bool isCallValid,
    320                                     ShadingModel modePacked);
    321 angle::CallCapture CaptureTexCoordPointer(const State &glState,
    322                                          bool isCallValid,
    323                                          GLint size,
    324                                          VertexAttribType typePacked,
    325                                          GLsizei stride,
    326                                          const void *pointer);
    327 angle::CallCapture CaptureTexEnvf(const State &glState,
    328                                  bool isCallValid,
    329                                  TextureEnvTarget targetPacked,
    330                                  TextureEnvParameter pnamePacked,
    331                                  GLfloat param);
    332 angle::CallCapture CaptureTexEnvfv(const State &glState,
    333                                   bool isCallValid,
    334                                   TextureEnvTarget targetPacked,
    335                                   TextureEnvParameter pnamePacked,
    336                                   const GLfloat *params);
    337 angle::CallCapture CaptureTexEnvi(const State &glState,
    338                                  bool isCallValid,
    339                                  TextureEnvTarget targetPacked,
    340                                  TextureEnvParameter pnamePacked,
    341                                  GLint param);
    342 angle::CallCapture CaptureTexEnviv(const State &glState,
    343                                   bool isCallValid,
    344                                   TextureEnvTarget targetPacked,
    345                                   TextureEnvParameter pnamePacked,
    346                                   const GLint *params);
    347 angle::CallCapture CaptureTexEnvx(const State &glState,
    348                                  bool isCallValid,
    349                                  TextureEnvTarget targetPacked,
    350                                  TextureEnvParameter pnamePacked,
    351                                  GLfixed param);
    352 angle::CallCapture CaptureTexEnvxv(const State &glState,
    353                                   bool isCallValid,
    354                                   TextureEnvTarget targetPacked,
    355                                   TextureEnvParameter pnamePacked,
    356                                   const GLfixed *params);
    357 angle::CallCapture CaptureTexParameterx(const State &glState,
    358                                        bool isCallValid,
    359                                        TextureType targetPacked,
    360                                        GLenum pname,
    361                                        GLfixed param);
    362 angle::CallCapture CaptureTexParameterxv(const State &glState,
    363                                         bool isCallValid,
    364                                         TextureType targetPacked,
    365                                         GLenum pname,
    366                                         const GLfixed *params);
    367 angle::CallCapture CaptureTranslatef(const State &glState,
    368                                     bool isCallValid,
    369                                     GLfloat x,
    370                                     GLfloat y,
    371                                     GLfloat z);
    372 angle::CallCapture CaptureTranslatex(const State &glState,
    373                                     bool isCallValid,
    374                                     GLfixed x,
    375                                     GLfixed y,
    376                                     GLfixed z);
    377 angle::CallCapture CaptureVertexPointer(const State &glState,
    378                                        bool isCallValid,
    379                                        GLint size,
    380                                        VertexAttribType typePacked,
    381                                        GLsizei stride,
    382                                        const void *pointer);
    383 
    384 // Parameter Captures
    385 
    386 void CaptureClipPlanef_eqn(const State &glState,
    387                           bool isCallValid,
    388                           GLenum p,
    389                           const GLfloat *eqn,
    390                           angle::ParamCapture *paramCapture);
    391 void CaptureClipPlanex_equation(const State &glState,
    392                                bool isCallValid,
    393                                GLenum plane,
    394                                const GLfixed *equation,
    395                                angle::ParamCapture *paramCapture);
    396 void CaptureColorPointer_pointer(const State &glState,
    397                                 bool isCallValid,
    398                                 GLint size,
    399                                 VertexAttribType typePacked,
    400                                 GLsizei stride,
    401                                 const void *pointer,
    402                                 angle::ParamCapture *paramCapture);
    403 void CaptureFogfv_params(const State &glState,
    404                         bool isCallValid,
    405                         GLenum pname,
    406                         const GLfloat *params,
    407                         angle::ParamCapture *paramCapture);
    408 void CaptureFogxv_param(const State &glState,
    409                        bool isCallValid,
    410                        GLenum pname,
    411                        const GLfixed *param,
    412                        angle::ParamCapture *paramCapture);
    413 void CaptureGetClipPlanef_equation(const State &glState,
    414                                   bool isCallValid,
    415                                   GLenum plane,
    416                                   GLfloat *equation,
    417                                   angle::ParamCapture *paramCapture);
    418 void CaptureGetClipPlanex_equation(const State &glState,
    419                                   bool isCallValid,
    420                                   GLenum plane,
    421                                   GLfixed *equation,
    422                                   angle::ParamCapture *paramCapture);
    423 void CaptureGetFixedv_params(const State &glState,
    424                             bool isCallValid,
    425                             GLenum pname,
    426                             GLfixed *params,
    427                             angle::ParamCapture *paramCapture);
    428 void CaptureGetLightfv_params(const State &glState,
    429                              bool isCallValid,
    430                              GLenum light,
    431                              LightParameter pnamePacked,
    432                              GLfloat *params,
    433                              angle::ParamCapture *paramCapture);
    434 void CaptureGetLightxv_params(const State &glState,
    435                              bool isCallValid,
    436                              GLenum light,
    437                              LightParameter pnamePacked,
    438                              GLfixed *params,
    439                              angle::ParamCapture *paramCapture);
    440 void CaptureGetMaterialfv_params(const State &glState,
    441                                 bool isCallValid,
    442                                 GLenum face,
    443                                 MaterialParameter pnamePacked,
    444                                 GLfloat *params,
    445                                 angle::ParamCapture *paramCapture);
    446 void CaptureGetMaterialxv_params(const State &glState,
    447                                 bool isCallValid,
    448                                 GLenum face,
    449                                 MaterialParameter pnamePacked,
    450                                 GLfixed *params,
    451                                 angle::ParamCapture *paramCapture);
    452 void CaptureGetTexEnvfv_params(const State &glState,
    453                               bool isCallValid,
    454                               TextureEnvTarget targetPacked,
    455                               TextureEnvParameter pnamePacked,
    456                               GLfloat *params,
    457                               angle::ParamCapture *paramCapture);
    458 void CaptureGetTexEnviv_params(const State &glState,
    459                               bool isCallValid,
    460                               TextureEnvTarget targetPacked,
    461                               TextureEnvParameter pnamePacked,
    462                               GLint *params,
    463                               angle::ParamCapture *paramCapture);
    464 void CaptureGetTexEnvxv_params(const State &glState,
    465                               bool isCallValid,
    466                               TextureEnvTarget targetPacked,
    467                               TextureEnvParameter pnamePacked,
    468                               GLfixed *params,
    469                               angle::ParamCapture *paramCapture);
    470 void CaptureGetTexParameterxv_params(const State &glState,
    471                                     bool isCallValid,
    472                                     TextureType targetPacked,
    473                                     GLenum pname,
    474                                     GLfixed *params,
    475                                     angle::ParamCapture *paramCapture);
    476 void CaptureLightModelfv_params(const State &glState,
    477                                bool isCallValid,
    478                                GLenum pname,
    479                                const GLfloat *params,
    480                                angle::ParamCapture *paramCapture);
    481 void CaptureLightModelxv_param(const State &glState,
    482                               bool isCallValid,
    483                               GLenum pname,
    484                               const GLfixed *param,
    485                               angle::ParamCapture *paramCapture);
    486 void CaptureLightfv_params(const State &glState,
    487                           bool isCallValid,
    488                           GLenum light,
    489                           LightParameter pnamePacked,
    490                           const GLfloat *params,
    491                           angle::ParamCapture *paramCapture);
    492 void CaptureLightxv_params(const State &glState,
    493                           bool isCallValid,
    494                           GLenum light,
    495                           LightParameter pnamePacked,
    496                           const GLfixed *params,
    497                           angle::ParamCapture *paramCapture);
    498 void CaptureLoadMatrixf_m(const State &glState,
    499                          bool isCallValid,
    500                          const GLfloat *m,
    501                          angle::ParamCapture *paramCapture);
    502 void CaptureLoadMatrixx_m(const State &glState,
    503                          bool isCallValid,
    504                          const GLfixed *m,
    505                          angle::ParamCapture *paramCapture);
    506 void CaptureMaterialfv_params(const State &glState,
    507                              bool isCallValid,
    508                              GLenum face,
    509                              MaterialParameter pnamePacked,
    510                              const GLfloat *params,
    511                              angle::ParamCapture *paramCapture);
    512 void CaptureMaterialxv_param(const State &glState,
    513                             bool isCallValid,
    514                             GLenum face,
    515                             MaterialParameter pnamePacked,
    516                             const GLfixed *param,
    517                             angle::ParamCapture *paramCapture);
    518 void CaptureMultMatrixf_m(const State &glState,
    519                          bool isCallValid,
    520                          const GLfloat *m,
    521                          angle::ParamCapture *paramCapture);
    522 void CaptureMultMatrixx_m(const State &glState,
    523                          bool isCallValid,
    524                          const GLfixed *m,
    525                          angle::ParamCapture *paramCapture);
    526 void CaptureNormalPointer_pointer(const State &glState,
    527                                  bool isCallValid,
    528                                  VertexAttribType typePacked,
    529                                  GLsizei stride,
    530                                  const void *pointer,
    531                                  angle::ParamCapture *paramCapture);
    532 void CapturePointParameterfv_params(const State &glState,
    533                                    bool isCallValid,
    534                                    PointParameter pnamePacked,
    535                                    const GLfloat *params,
    536                                    angle::ParamCapture *paramCapture);
    537 void CapturePointParameterxv_params(const State &glState,
    538                                    bool isCallValid,
    539                                    PointParameter pnamePacked,
    540                                    const GLfixed *params,
    541                                    angle::ParamCapture *paramCapture);
    542 void CaptureTexCoordPointer_pointer(const State &glState,
    543                                    bool isCallValid,
    544                                    GLint size,
    545                                    VertexAttribType typePacked,
    546                                    GLsizei stride,
    547                                    const void *pointer,
    548                                    angle::ParamCapture *paramCapture);
    549 void CaptureTexEnvfv_params(const State &glState,
    550                            bool isCallValid,
    551                            TextureEnvTarget targetPacked,
    552                            TextureEnvParameter pnamePacked,
    553                            const GLfloat *params,
    554                            angle::ParamCapture *paramCapture);
    555 void CaptureTexEnviv_params(const State &glState,
    556                            bool isCallValid,
    557                            TextureEnvTarget targetPacked,
    558                            TextureEnvParameter pnamePacked,
    559                            const GLint *params,
    560                            angle::ParamCapture *paramCapture);
    561 void CaptureTexEnvxv_params(const State &glState,
    562                            bool isCallValid,
    563                            TextureEnvTarget targetPacked,
    564                            TextureEnvParameter pnamePacked,
    565                            const GLfixed *params,
    566                            angle::ParamCapture *paramCapture);
    567 void CaptureTexParameterxv_params(const State &glState,
    568                                  bool isCallValid,
    569                                  TextureType targetPacked,
    570                                  GLenum pname,
    571                                  const GLfixed *params,
    572                                  angle::ParamCapture *paramCapture);
    573 void CaptureVertexPointer_pointer(const State &glState,
    574                                  bool isCallValid,
    575                                  GLint size,
    576                                  VertexAttribType typePacked,
    577                                  GLsizei stride,
    578                                  const void *pointer,
    579                                  angle::ParamCapture *paramCapture);
    580 }  // namespace gl
    581 
    582 #endif  // LIBANGLE_CAPTURE_GLES_1_0_AUTOGEN_H_