tor-browser

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

capture_gles_2_0_autogen.h (70462B)


      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_2_0_autogen.h:
      9 //   Capture functions for the OpenGL ES 2.0 entry points.
     10 
     11 #ifndef LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_
     12 #define LIBANGLE_CAPTURE_GLES_2_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 CaptureActiveTexture(const State &glState, bool isCallValid, GLenum texture);
     23 angle::CallCapture CaptureAttachShader(const State &glState,
     24                                       bool isCallValid,
     25                                       ShaderProgramID programPacked,
     26                                       ShaderProgramID shaderPacked);
     27 angle::CallCapture CaptureBindAttribLocation(const State &glState,
     28                                             bool isCallValid,
     29                                             ShaderProgramID programPacked,
     30                                             GLuint index,
     31                                             const GLchar *name);
     32 angle::CallCapture CaptureBindBuffer(const State &glState,
     33                                     bool isCallValid,
     34                                     BufferBinding targetPacked,
     35                                     BufferID bufferPacked);
     36 angle::CallCapture CaptureBindFramebuffer(const State &glState,
     37                                          bool isCallValid,
     38                                          GLenum target,
     39                                          FramebufferID framebufferPacked);
     40 angle::CallCapture CaptureBindRenderbuffer(const State &glState,
     41                                           bool isCallValid,
     42                                           GLenum target,
     43                                           RenderbufferID renderbufferPacked);
     44 angle::CallCapture CaptureBindTexture(const State &glState,
     45                                      bool isCallValid,
     46                                      TextureType targetPacked,
     47                                      TextureID texturePacked);
     48 angle::CallCapture CaptureBlendColor(const State &glState,
     49                                     bool isCallValid,
     50                                     GLfloat red,
     51                                     GLfloat green,
     52                                     GLfloat blue,
     53                                     GLfloat alpha);
     54 angle::CallCapture CaptureBlendEquation(const State &glState, bool isCallValid, GLenum mode);
     55 angle::CallCapture CaptureBlendEquationSeparate(const State &glState,
     56                                                bool isCallValid,
     57                                                GLenum modeRGB,
     58                                                GLenum modeAlpha);
     59 angle::CallCapture CaptureBlendFunc(const State &glState,
     60                                    bool isCallValid,
     61                                    GLenum sfactor,
     62                                    GLenum dfactor);
     63 angle::CallCapture CaptureBlendFuncSeparate(const State &glState,
     64                                            bool isCallValid,
     65                                            GLenum sfactorRGB,
     66                                            GLenum dfactorRGB,
     67                                            GLenum sfactorAlpha,
     68                                            GLenum dfactorAlpha);
     69 angle::CallCapture CaptureBufferData(const State &glState,
     70                                     bool isCallValid,
     71                                     BufferBinding targetPacked,
     72                                     GLsizeiptr size,
     73                                     const void *data,
     74                                     BufferUsage usagePacked);
     75 angle::CallCapture CaptureBufferSubData(const State &glState,
     76                                        bool isCallValid,
     77                                        BufferBinding targetPacked,
     78                                        GLintptr offset,
     79                                        GLsizeiptr size,
     80                                        const void *data);
     81 angle::CallCapture CaptureCheckFramebufferStatus(const State &glState,
     82                                                 bool isCallValid,
     83                                                 GLenum target,
     84                                                 GLenum returnValue);
     85 angle::CallCapture CaptureClear(const State &glState, bool isCallValid, GLbitfield mask);
     86 angle::CallCapture CaptureClearColor(const State &glState,
     87                                     bool isCallValid,
     88                                     GLfloat red,
     89                                     GLfloat green,
     90                                     GLfloat blue,
     91                                     GLfloat alpha);
     92 angle::CallCapture CaptureClearDepthf(const State &glState, bool isCallValid, GLfloat d);
     93 angle::CallCapture CaptureClearStencil(const State &glState, bool isCallValid, GLint s);
     94 angle::CallCapture CaptureColorMask(const State &glState,
     95                                    bool isCallValid,
     96                                    GLboolean red,
     97                                    GLboolean green,
     98                                    GLboolean blue,
     99                                    GLboolean alpha);
    100 angle::CallCapture CaptureCompileShader(const State &glState,
    101                                        bool isCallValid,
    102                                        ShaderProgramID shaderPacked);
    103 angle::CallCapture CaptureCompressedTexImage2D(const State &glState,
    104                                               bool isCallValid,
    105                                               TextureTarget targetPacked,
    106                                               GLint level,
    107                                               GLenum internalformat,
    108                                               GLsizei width,
    109                                               GLsizei height,
    110                                               GLint border,
    111                                               GLsizei imageSize,
    112                                               const void *data);
    113 angle::CallCapture CaptureCompressedTexSubImage2D(const State &glState,
    114                                                  bool isCallValid,
    115                                                  TextureTarget targetPacked,
    116                                                  GLint level,
    117                                                  GLint xoffset,
    118                                                  GLint yoffset,
    119                                                  GLsizei width,
    120                                                  GLsizei height,
    121                                                  GLenum format,
    122                                                  GLsizei imageSize,
    123                                                  const void *data);
    124 angle::CallCapture CaptureCopyTexImage2D(const State &glState,
    125                                         bool isCallValid,
    126                                         TextureTarget targetPacked,
    127                                         GLint level,
    128                                         GLenum internalformat,
    129                                         GLint x,
    130                                         GLint y,
    131                                         GLsizei width,
    132                                         GLsizei height,
    133                                         GLint border);
    134 angle::CallCapture CaptureCopyTexSubImage2D(const State &glState,
    135                                            bool isCallValid,
    136                                            TextureTarget targetPacked,
    137                                            GLint level,
    138                                            GLint xoffset,
    139                                            GLint yoffset,
    140                                            GLint x,
    141                                            GLint y,
    142                                            GLsizei width,
    143                                            GLsizei height);
    144 angle::CallCapture CaptureCreateProgram(const State &glState, bool isCallValid, GLuint returnValue);
    145 angle::CallCapture CaptureCreateShader(const State &glState,
    146                                       bool isCallValid,
    147                                       ShaderType typePacked,
    148                                       GLuint returnValue);
    149 angle::CallCapture CaptureCullFace(const State &glState, bool isCallValid, CullFaceMode modePacked);
    150 angle::CallCapture CaptureDeleteBuffers(const State &glState,
    151                                        bool isCallValid,
    152                                        GLsizei n,
    153                                        const BufferID *buffersPacked);
    154 angle::CallCapture CaptureDeleteFramebuffers(const State &glState,
    155                                             bool isCallValid,
    156                                             GLsizei n,
    157                                             const FramebufferID *framebuffersPacked);
    158 angle::CallCapture CaptureDeleteProgram(const State &glState,
    159                                        bool isCallValid,
    160                                        ShaderProgramID programPacked);
    161 angle::CallCapture CaptureDeleteRenderbuffers(const State &glState,
    162                                              bool isCallValid,
    163                                              GLsizei n,
    164                                              const RenderbufferID *renderbuffersPacked);
    165 angle::CallCapture CaptureDeleteShader(const State &glState,
    166                                       bool isCallValid,
    167                                       ShaderProgramID shaderPacked);
    168 angle::CallCapture CaptureDeleteTextures(const State &glState,
    169                                         bool isCallValid,
    170                                         GLsizei n,
    171                                         const TextureID *texturesPacked);
    172 angle::CallCapture CaptureDepthFunc(const State &glState, bool isCallValid, GLenum func);
    173 angle::CallCapture CaptureDepthMask(const State &glState, bool isCallValid, GLboolean flag);
    174 angle::CallCapture CaptureDepthRangef(const State &glState, bool isCallValid, GLfloat n, GLfloat f);
    175 angle::CallCapture CaptureDetachShader(const State &glState,
    176                                       bool isCallValid,
    177                                       ShaderProgramID programPacked,
    178                                       ShaderProgramID shaderPacked);
    179 angle::CallCapture CaptureDisable(const State &glState, bool isCallValid, GLenum cap);
    180 angle::CallCapture CaptureDisableVertexAttribArray(const State &glState,
    181                                                   bool isCallValid,
    182                                                   GLuint index);
    183 angle::CallCapture CaptureDrawArrays(const State &glState,
    184                                     bool isCallValid,
    185                                     PrimitiveMode modePacked,
    186                                     GLint first,
    187                                     GLsizei count);
    188 angle::CallCapture CaptureDrawElements(const State &glState,
    189                                       bool isCallValid,
    190                                       PrimitiveMode modePacked,
    191                                       GLsizei count,
    192                                       DrawElementsType typePacked,
    193                                       const void *indices);
    194 angle::CallCapture CaptureEnable(const State &glState, bool isCallValid, GLenum cap);
    195 angle::CallCapture CaptureEnableVertexAttribArray(const State &glState,
    196                                                  bool isCallValid,
    197                                                  GLuint index);
    198 angle::CallCapture CaptureFinish(const State &glState, bool isCallValid);
    199 angle::CallCapture CaptureFlush(const State &glState, bool isCallValid);
    200 angle::CallCapture CaptureFramebufferRenderbuffer(const State &glState,
    201                                                  bool isCallValid,
    202                                                  GLenum target,
    203                                                  GLenum attachment,
    204                                                  GLenum renderbuffertarget,
    205                                                  RenderbufferID renderbufferPacked);
    206 angle::CallCapture CaptureFramebufferTexture2D(const State &glState,
    207                                               bool isCallValid,
    208                                               GLenum target,
    209                                               GLenum attachment,
    210                                               TextureTarget textargetPacked,
    211                                               TextureID texturePacked,
    212                                               GLint level);
    213 angle::CallCapture CaptureFrontFace(const State &glState, bool isCallValid, GLenum mode);
    214 angle::CallCapture CaptureGenBuffers(const State &glState,
    215                                     bool isCallValid,
    216                                     GLsizei n,
    217                                     BufferID *buffersPacked);
    218 angle::CallCapture CaptureGenFramebuffers(const State &glState,
    219                                          bool isCallValid,
    220                                          GLsizei n,
    221                                          FramebufferID *framebuffersPacked);
    222 angle::CallCapture CaptureGenRenderbuffers(const State &glState,
    223                                           bool isCallValid,
    224                                           GLsizei n,
    225                                           RenderbufferID *renderbuffersPacked);
    226 angle::CallCapture CaptureGenTextures(const State &glState,
    227                                      bool isCallValid,
    228                                      GLsizei n,
    229                                      TextureID *texturesPacked);
    230 angle::CallCapture CaptureGenerateMipmap(const State &glState,
    231                                         bool isCallValid,
    232                                         TextureType targetPacked);
    233 angle::CallCapture CaptureGetActiveAttrib(const State &glState,
    234                                          bool isCallValid,
    235                                          ShaderProgramID programPacked,
    236                                          GLuint index,
    237                                          GLsizei bufSize,
    238                                          GLsizei *length,
    239                                          GLint *size,
    240                                          GLenum *type,
    241                                          GLchar *name);
    242 angle::CallCapture CaptureGetActiveUniform(const State &glState,
    243                                           bool isCallValid,
    244                                           ShaderProgramID programPacked,
    245                                           GLuint index,
    246                                           GLsizei bufSize,
    247                                           GLsizei *length,
    248                                           GLint *size,
    249                                           GLenum *type,
    250                                           GLchar *name);
    251 angle::CallCapture CaptureGetAttachedShaders(const State &glState,
    252                                             bool isCallValid,
    253                                             ShaderProgramID programPacked,
    254                                             GLsizei maxCount,
    255                                             GLsizei *count,
    256                                             ShaderProgramID *shadersPacked);
    257 angle::CallCapture CaptureGetAttribLocation(const State &glState,
    258                                            bool isCallValid,
    259                                            ShaderProgramID programPacked,
    260                                            const GLchar *name,
    261                                            GLint returnValue);
    262 angle::CallCapture CaptureGetBooleanv(const State &glState,
    263                                      bool isCallValid,
    264                                      GLenum pname,
    265                                      GLboolean *data);
    266 angle::CallCapture CaptureGetBufferParameteriv(const State &glState,
    267                                               bool isCallValid,
    268                                               BufferBinding targetPacked,
    269                                               GLenum pname,
    270                                               GLint *params);
    271 angle::CallCapture CaptureGetError(const State &glState, bool isCallValid, GLenum returnValue);
    272 angle::CallCapture CaptureGetFloatv(const State &glState,
    273                                    bool isCallValid,
    274                                    GLenum pname,
    275                                    GLfloat *data);
    276 angle::CallCapture CaptureGetFramebufferAttachmentParameteriv(const State &glState,
    277                                                              bool isCallValid,
    278                                                              GLenum target,
    279                                                              GLenum attachment,
    280                                                              GLenum pname,
    281                                                              GLint *params);
    282 angle::CallCapture CaptureGetIntegerv(const State &glState,
    283                                      bool isCallValid,
    284                                      GLenum pname,
    285                                      GLint *data);
    286 angle::CallCapture CaptureGetProgramInfoLog(const State &glState,
    287                                            bool isCallValid,
    288                                            ShaderProgramID programPacked,
    289                                            GLsizei bufSize,
    290                                            GLsizei *length,
    291                                            GLchar *infoLog);
    292 angle::CallCapture CaptureGetProgramiv(const State &glState,
    293                                       bool isCallValid,
    294                                       ShaderProgramID programPacked,
    295                                       GLenum pname,
    296                                       GLint *params);
    297 angle::CallCapture CaptureGetRenderbufferParameteriv(const State &glState,
    298                                                     bool isCallValid,
    299                                                     GLenum target,
    300                                                     GLenum pname,
    301                                                     GLint *params);
    302 angle::CallCapture CaptureGetShaderInfoLog(const State &glState,
    303                                           bool isCallValid,
    304                                           ShaderProgramID shaderPacked,
    305                                           GLsizei bufSize,
    306                                           GLsizei *length,
    307                                           GLchar *infoLog);
    308 angle::CallCapture CaptureGetShaderPrecisionFormat(const State &glState,
    309                                                   bool isCallValid,
    310                                                   GLenum shadertype,
    311                                                   GLenum precisiontype,
    312                                                   GLint *range,
    313                                                   GLint *precision);
    314 angle::CallCapture CaptureGetShaderSource(const State &glState,
    315                                          bool isCallValid,
    316                                          ShaderProgramID shaderPacked,
    317                                          GLsizei bufSize,
    318                                          GLsizei *length,
    319                                          GLchar *source);
    320 angle::CallCapture CaptureGetShaderiv(const State &glState,
    321                                      bool isCallValid,
    322                                      ShaderProgramID shaderPacked,
    323                                      GLenum pname,
    324                                      GLint *params);
    325 angle::CallCapture CaptureGetString(const State &glState,
    326                                    bool isCallValid,
    327                                    GLenum name,
    328                                    const GLubyte *returnValue);
    329 angle::CallCapture CaptureGetTexParameterfv(const State &glState,
    330                                            bool isCallValid,
    331                                            TextureType targetPacked,
    332                                            GLenum pname,
    333                                            GLfloat *params);
    334 angle::CallCapture CaptureGetTexParameteriv(const State &glState,
    335                                            bool isCallValid,
    336                                            TextureType targetPacked,
    337                                            GLenum pname,
    338                                            GLint *params);
    339 angle::CallCapture CaptureGetUniformLocation(const State &glState,
    340                                             bool isCallValid,
    341                                             ShaderProgramID programPacked,
    342                                             const GLchar *name,
    343                                             GLint returnValue);
    344 angle::CallCapture CaptureGetUniformfv(const State &glState,
    345                                       bool isCallValid,
    346                                       ShaderProgramID programPacked,
    347                                       UniformLocation locationPacked,
    348                                       GLfloat *params);
    349 angle::CallCapture CaptureGetUniformiv(const State &glState,
    350                                       bool isCallValid,
    351                                       ShaderProgramID programPacked,
    352                                       UniformLocation locationPacked,
    353                                       GLint *params);
    354 angle::CallCapture CaptureGetVertexAttribPointerv(const State &glState,
    355                                                  bool isCallValid,
    356                                                  GLuint index,
    357                                                  GLenum pname,
    358                                                  void **pointer);
    359 angle::CallCapture CaptureGetVertexAttribfv(const State &glState,
    360                                            bool isCallValid,
    361                                            GLuint index,
    362                                            GLenum pname,
    363                                            GLfloat *params);
    364 angle::CallCapture CaptureGetVertexAttribiv(const State &glState,
    365                                            bool isCallValid,
    366                                            GLuint index,
    367                                            GLenum pname,
    368                                            GLint *params);
    369 angle::CallCapture CaptureHint(const State &glState, bool isCallValid, GLenum target, GLenum mode);
    370 angle::CallCapture CaptureIsBuffer(const State &glState,
    371                                   bool isCallValid,
    372                                   BufferID bufferPacked,
    373                                   GLboolean returnValue);
    374 angle::CallCapture CaptureIsEnabled(const State &glState,
    375                                    bool isCallValid,
    376                                    GLenum cap,
    377                                    GLboolean returnValue);
    378 angle::CallCapture CaptureIsFramebuffer(const State &glState,
    379                                        bool isCallValid,
    380                                        FramebufferID framebufferPacked,
    381                                        GLboolean returnValue);
    382 angle::CallCapture CaptureIsProgram(const State &glState,
    383                                    bool isCallValid,
    384                                    ShaderProgramID programPacked,
    385                                    GLboolean returnValue);
    386 angle::CallCapture CaptureIsRenderbuffer(const State &glState,
    387                                         bool isCallValid,
    388                                         RenderbufferID renderbufferPacked,
    389                                         GLboolean returnValue);
    390 angle::CallCapture CaptureIsShader(const State &glState,
    391                                   bool isCallValid,
    392                                   ShaderProgramID shaderPacked,
    393                                   GLboolean returnValue);
    394 angle::CallCapture CaptureIsTexture(const State &glState,
    395                                    bool isCallValid,
    396                                    TextureID texturePacked,
    397                                    GLboolean returnValue);
    398 angle::CallCapture CaptureLineWidth(const State &glState, bool isCallValid, GLfloat width);
    399 angle::CallCapture CaptureLinkProgram(const State &glState,
    400                                      bool isCallValid,
    401                                      ShaderProgramID programPacked);
    402 angle::CallCapture CapturePixelStorei(const State &glState,
    403                                      bool isCallValid,
    404                                      GLenum pname,
    405                                      GLint param);
    406 angle::CallCapture CapturePolygonOffset(const State &glState,
    407                                        bool isCallValid,
    408                                        GLfloat factor,
    409                                        GLfloat units);
    410 angle::CallCapture CaptureReadPixels(const State &glState,
    411                                     bool isCallValid,
    412                                     GLint x,
    413                                     GLint y,
    414                                     GLsizei width,
    415                                     GLsizei height,
    416                                     GLenum format,
    417                                     GLenum type,
    418                                     void *pixels);
    419 angle::CallCapture CaptureReleaseShaderCompiler(const State &glState, bool isCallValid);
    420 angle::CallCapture CaptureRenderbufferStorage(const State &glState,
    421                                              bool isCallValid,
    422                                              GLenum target,
    423                                              GLenum internalformat,
    424                                              GLsizei width,
    425                                              GLsizei height);
    426 angle::CallCapture CaptureSampleCoverage(const State &glState,
    427                                         bool isCallValid,
    428                                         GLfloat value,
    429                                         GLboolean invert);
    430 angle::CallCapture CaptureScissor(const State &glState,
    431                                  bool isCallValid,
    432                                  GLint x,
    433                                  GLint y,
    434                                  GLsizei width,
    435                                  GLsizei height);
    436 angle::CallCapture CaptureShaderBinary(const State &glState,
    437                                       bool isCallValid,
    438                                       GLsizei count,
    439                                       const ShaderProgramID *shadersPacked,
    440                                       GLenum binaryFormat,
    441                                       const void *binary,
    442                                       GLsizei length);
    443 angle::CallCapture CaptureShaderSource(const State &glState,
    444                                       bool isCallValid,
    445                                       ShaderProgramID shaderPacked,
    446                                       GLsizei count,
    447                                       const GLchar *const *string,
    448                                       const GLint *length);
    449 angle::CallCapture CaptureStencilFunc(const State &glState,
    450                                      bool isCallValid,
    451                                      GLenum func,
    452                                      GLint ref,
    453                                      GLuint mask);
    454 angle::CallCapture CaptureStencilFuncSeparate(const State &glState,
    455                                              bool isCallValid,
    456                                              GLenum face,
    457                                              GLenum func,
    458                                              GLint ref,
    459                                              GLuint mask);
    460 angle::CallCapture CaptureStencilMask(const State &glState, bool isCallValid, GLuint mask);
    461 angle::CallCapture CaptureStencilMaskSeparate(const State &glState,
    462                                              bool isCallValid,
    463                                              GLenum face,
    464                                              GLuint mask);
    465 angle::CallCapture CaptureStencilOp(const State &glState,
    466                                    bool isCallValid,
    467                                    GLenum fail,
    468                                    GLenum zfail,
    469                                    GLenum zpass);
    470 angle::CallCapture CaptureStencilOpSeparate(const State &glState,
    471                                            bool isCallValid,
    472                                            GLenum face,
    473                                            GLenum sfail,
    474                                            GLenum dpfail,
    475                                            GLenum dppass);
    476 angle::CallCapture CaptureTexImage2D(const State &glState,
    477                                     bool isCallValid,
    478                                     TextureTarget targetPacked,
    479                                     GLint level,
    480                                     GLint internalformat,
    481                                     GLsizei width,
    482                                     GLsizei height,
    483                                     GLint border,
    484                                     GLenum format,
    485                                     GLenum type,
    486                                     const void *pixels);
    487 angle::CallCapture CaptureTexParameterf(const State &glState,
    488                                        bool isCallValid,
    489                                        TextureType targetPacked,
    490                                        GLenum pname,
    491                                        GLfloat param);
    492 angle::CallCapture CaptureTexParameterfv(const State &glState,
    493                                         bool isCallValid,
    494                                         TextureType targetPacked,
    495                                         GLenum pname,
    496                                         const GLfloat *params);
    497 angle::CallCapture CaptureTexParameteri(const State &glState,
    498                                        bool isCallValid,
    499                                        TextureType targetPacked,
    500                                        GLenum pname,
    501                                        GLint param);
    502 angle::CallCapture CaptureTexParameteriv(const State &glState,
    503                                         bool isCallValid,
    504                                         TextureType targetPacked,
    505                                         GLenum pname,
    506                                         const GLint *params);
    507 angle::CallCapture CaptureTexSubImage2D(const State &glState,
    508                                        bool isCallValid,
    509                                        TextureTarget targetPacked,
    510                                        GLint level,
    511                                        GLint xoffset,
    512                                        GLint yoffset,
    513                                        GLsizei width,
    514                                        GLsizei height,
    515                                        GLenum format,
    516                                        GLenum type,
    517                                        const void *pixels);
    518 angle::CallCapture CaptureUniform1f(const State &glState,
    519                                    bool isCallValid,
    520                                    UniformLocation locationPacked,
    521                                    GLfloat v0);
    522 angle::CallCapture CaptureUniform1fv(const State &glState,
    523                                     bool isCallValid,
    524                                     UniformLocation locationPacked,
    525                                     GLsizei count,
    526                                     const GLfloat *value);
    527 angle::CallCapture CaptureUniform1i(const State &glState,
    528                                    bool isCallValid,
    529                                    UniformLocation locationPacked,
    530                                    GLint v0);
    531 angle::CallCapture CaptureUniform1iv(const State &glState,
    532                                     bool isCallValid,
    533                                     UniformLocation locationPacked,
    534                                     GLsizei count,
    535                                     const GLint *value);
    536 angle::CallCapture CaptureUniform2f(const State &glState,
    537                                    bool isCallValid,
    538                                    UniformLocation locationPacked,
    539                                    GLfloat v0,
    540                                    GLfloat v1);
    541 angle::CallCapture CaptureUniform2fv(const State &glState,
    542                                     bool isCallValid,
    543                                     UniformLocation locationPacked,
    544                                     GLsizei count,
    545                                     const GLfloat *value);
    546 angle::CallCapture CaptureUniform2i(const State &glState,
    547                                    bool isCallValid,
    548                                    UniformLocation locationPacked,
    549                                    GLint v0,
    550                                    GLint v1);
    551 angle::CallCapture CaptureUniform2iv(const State &glState,
    552                                     bool isCallValid,
    553                                     UniformLocation locationPacked,
    554                                     GLsizei count,
    555                                     const GLint *value);
    556 angle::CallCapture CaptureUniform3f(const State &glState,
    557                                    bool isCallValid,
    558                                    UniformLocation locationPacked,
    559                                    GLfloat v0,
    560                                    GLfloat v1,
    561                                    GLfloat v2);
    562 angle::CallCapture CaptureUniform3fv(const State &glState,
    563                                     bool isCallValid,
    564                                     UniformLocation locationPacked,
    565                                     GLsizei count,
    566                                     const GLfloat *value);
    567 angle::CallCapture CaptureUniform3i(const State &glState,
    568                                    bool isCallValid,
    569                                    UniformLocation locationPacked,
    570                                    GLint v0,
    571                                    GLint v1,
    572                                    GLint v2);
    573 angle::CallCapture CaptureUniform3iv(const State &glState,
    574                                     bool isCallValid,
    575                                     UniformLocation locationPacked,
    576                                     GLsizei count,
    577                                     const GLint *value);
    578 angle::CallCapture CaptureUniform4f(const State &glState,
    579                                    bool isCallValid,
    580                                    UniformLocation locationPacked,
    581                                    GLfloat v0,
    582                                    GLfloat v1,
    583                                    GLfloat v2,
    584                                    GLfloat v3);
    585 angle::CallCapture CaptureUniform4fv(const State &glState,
    586                                     bool isCallValid,
    587                                     UniformLocation locationPacked,
    588                                     GLsizei count,
    589                                     const GLfloat *value);
    590 angle::CallCapture CaptureUniform4i(const State &glState,
    591                                    bool isCallValid,
    592                                    UniformLocation locationPacked,
    593                                    GLint v0,
    594                                    GLint v1,
    595                                    GLint v2,
    596                                    GLint v3);
    597 angle::CallCapture CaptureUniform4iv(const State &glState,
    598                                     bool isCallValid,
    599                                     UniformLocation locationPacked,
    600                                     GLsizei count,
    601                                     const GLint *value);
    602 angle::CallCapture CaptureUniformMatrix2fv(const State &glState,
    603                                           bool isCallValid,
    604                                           UniformLocation locationPacked,
    605                                           GLsizei count,
    606                                           GLboolean transpose,
    607                                           const GLfloat *value);
    608 angle::CallCapture CaptureUniformMatrix3fv(const State &glState,
    609                                           bool isCallValid,
    610                                           UniformLocation locationPacked,
    611                                           GLsizei count,
    612                                           GLboolean transpose,
    613                                           const GLfloat *value);
    614 angle::CallCapture CaptureUniformMatrix4fv(const State &glState,
    615                                           bool isCallValid,
    616                                           UniformLocation locationPacked,
    617                                           GLsizei count,
    618                                           GLboolean transpose,
    619                                           const GLfloat *value);
    620 angle::CallCapture CaptureUseProgram(const State &glState,
    621                                     bool isCallValid,
    622                                     ShaderProgramID programPacked);
    623 angle::CallCapture CaptureValidateProgram(const State &glState,
    624                                          bool isCallValid,
    625                                          ShaderProgramID programPacked);
    626 angle::CallCapture CaptureVertexAttrib1f(const State &glState,
    627                                         bool isCallValid,
    628                                         GLuint index,
    629                                         GLfloat x);
    630 angle::CallCapture CaptureVertexAttrib1fv(const State &glState,
    631                                          bool isCallValid,
    632                                          GLuint index,
    633                                          const GLfloat *v);
    634 angle::CallCapture CaptureVertexAttrib2f(const State &glState,
    635                                         bool isCallValid,
    636                                         GLuint index,
    637                                         GLfloat x,
    638                                         GLfloat y);
    639 angle::CallCapture CaptureVertexAttrib2fv(const State &glState,
    640                                          bool isCallValid,
    641                                          GLuint index,
    642                                          const GLfloat *v);
    643 angle::CallCapture CaptureVertexAttrib3f(const State &glState,
    644                                         bool isCallValid,
    645                                         GLuint index,
    646                                         GLfloat x,
    647                                         GLfloat y,
    648                                         GLfloat z);
    649 angle::CallCapture CaptureVertexAttrib3fv(const State &glState,
    650                                          bool isCallValid,
    651                                          GLuint index,
    652                                          const GLfloat *v);
    653 angle::CallCapture CaptureVertexAttrib4f(const State &glState,
    654                                         bool isCallValid,
    655                                         GLuint index,
    656                                         GLfloat x,
    657                                         GLfloat y,
    658                                         GLfloat z,
    659                                         GLfloat w);
    660 angle::CallCapture CaptureVertexAttrib4fv(const State &glState,
    661                                          bool isCallValid,
    662                                          GLuint index,
    663                                          const GLfloat *v);
    664 angle::CallCapture CaptureVertexAttribPointer(const State &glState,
    665                                              bool isCallValid,
    666                                              GLuint index,
    667                                              GLint size,
    668                                              VertexAttribType typePacked,
    669                                              GLboolean normalized,
    670                                              GLsizei stride,
    671                                              const void *pointer);
    672 angle::CallCapture CaptureViewport(const State &glState,
    673                                   bool isCallValid,
    674                                   GLint x,
    675                                   GLint y,
    676                                   GLsizei width,
    677                                   GLsizei height);
    678 
    679 // Parameter Captures
    680 
    681 void CaptureBindAttribLocation_name(const State &glState,
    682                                    bool isCallValid,
    683                                    ShaderProgramID programPacked,
    684                                    GLuint index,
    685                                    const GLchar *name,
    686                                    angle::ParamCapture *paramCapture);
    687 void CaptureBufferData_data(const State &glState,
    688                            bool isCallValid,
    689                            BufferBinding targetPacked,
    690                            GLsizeiptr size,
    691                            const void *data,
    692                            BufferUsage usagePacked,
    693                            angle::ParamCapture *paramCapture);
    694 void CaptureBufferSubData_data(const State &glState,
    695                               bool isCallValid,
    696                               BufferBinding targetPacked,
    697                               GLintptr offset,
    698                               GLsizeiptr size,
    699                               const void *data,
    700                               angle::ParamCapture *paramCapture);
    701 void CaptureCompressedTexImage2D_data(const State &glState,
    702                                      bool isCallValid,
    703                                      TextureTarget targetPacked,
    704                                      GLint level,
    705                                      GLenum internalformat,
    706                                      GLsizei width,
    707                                      GLsizei height,
    708                                      GLint border,
    709                                      GLsizei imageSize,
    710                                      const void *data,
    711                                      angle::ParamCapture *paramCapture);
    712 void CaptureCompressedTexSubImage2D_data(const State &glState,
    713                                         bool isCallValid,
    714                                         TextureTarget targetPacked,
    715                                         GLint level,
    716                                         GLint xoffset,
    717                                         GLint yoffset,
    718                                         GLsizei width,
    719                                         GLsizei height,
    720                                         GLenum format,
    721                                         GLsizei imageSize,
    722                                         const void *data,
    723                                         angle::ParamCapture *paramCapture);
    724 void CaptureDeleteBuffers_buffersPacked(const State &glState,
    725                                        bool isCallValid,
    726                                        GLsizei n,
    727                                        const BufferID *buffersPacked,
    728                                        angle::ParamCapture *paramCapture);
    729 void CaptureDeleteFramebuffers_framebuffersPacked(const State &glState,
    730                                                  bool isCallValid,
    731                                                  GLsizei n,
    732                                                  const FramebufferID *framebuffersPacked,
    733                                                  angle::ParamCapture *paramCapture);
    734 void CaptureDeleteRenderbuffers_renderbuffersPacked(const State &glState,
    735                                                    bool isCallValid,
    736                                                    GLsizei n,
    737                                                    const RenderbufferID *renderbuffersPacked,
    738                                                    angle::ParamCapture *paramCapture);
    739 void CaptureDeleteTextures_texturesPacked(const State &glState,
    740                                          bool isCallValid,
    741                                          GLsizei n,
    742                                          const TextureID *texturesPacked,
    743                                          angle::ParamCapture *paramCapture);
    744 void CaptureDrawElements_indices(const State &glState,
    745                                 bool isCallValid,
    746                                 PrimitiveMode modePacked,
    747                                 GLsizei count,
    748                                 DrawElementsType typePacked,
    749                                 const void *indices,
    750                                 angle::ParamCapture *paramCapture);
    751 void CaptureGenBuffers_buffersPacked(const State &glState,
    752                                     bool isCallValid,
    753                                     GLsizei n,
    754                                     BufferID *buffersPacked,
    755                                     angle::ParamCapture *paramCapture);
    756 void CaptureGenFramebuffers_framebuffersPacked(const State &glState,
    757                                               bool isCallValid,
    758                                               GLsizei n,
    759                                               FramebufferID *framebuffersPacked,
    760                                               angle::ParamCapture *paramCapture);
    761 void CaptureGenRenderbuffers_renderbuffersPacked(const State &glState,
    762                                                 bool isCallValid,
    763                                                 GLsizei n,
    764                                                 RenderbufferID *renderbuffersPacked,
    765                                                 angle::ParamCapture *paramCapture);
    766 void CaptureGenTextures_texturesPacked(const State &glState,
    767                                       bool isCallValid,
    768                                       GLsizei n,
    769                                       TextureID *texturesPacked,
    770                                       angle::ParamCapture *paramCapture);
    771 void CaptureGetActiveAttrib_length(const State &glState,
    772                                   bool isCallValid,
    773                                   ShaderProgramID programPacked,
    774                                   GLuint index,
    775                                   GLsizei bufSize,
    776                                   GLsizei *length,
    777                                   GLint *size,
    778                                   GLenum *type,
    779                                   GLchar *name,
    780                                   angle::ParamCapture *paramCapture);
    781 void CaptureGetActiveAttrib_size(const State &glState,
    782                                 bool isCallValid,
    783                                 ShaderProgramID programPacked,
    784                                 GLuint index,
    785                                 GLsizei bufSize,
    786                                 GLsizei *length,
    787                                 GLint *size,
    788                                 GLenum *type,
    789                                 GLchar *name,
    790                                 angle::ParamCapture *paramCapture);
    791 void CaptureGetActiveAttrib_type(const State &glState,
    792                                 bool isCallValid,
    793                                 ShaderProgramID programPacked,
    794                                 GLuint index,
    795                                 GLsizei bufSize,
    796                                 GLsizei *length,
    797                                 GLint *size,
    798                                 GLenum *type,
    799                                 GLchar *name,
    800                                 angle::ParamCapture *paramCapture);
    801 void CaptureGetActiveAttrib_name(const State &glState,
    802                                 bool isCallValid,
    803                                 ShaderProgramID programPacked,
    804                                 GLuint index,
    805                                 GLsizei bufSize,
    806                                 GLsizei *length,
    807                                 GLint *size,
    808                                 GLenum *type,
    809                                 GLchar *name,
    810                                 angle::ParamCapture *paramCapture);
    811 void CaptureGetActiveUniform_length(const State &glState,
    812                                    bool isCallValid,
    813                                    ShaderProgramID programPacked,
    814                                    GLuint index,
    815                                    GLsizei bufSize,
    816                                    GLsizei *length,
    817                                    GLint *size,
    818                                    GLenum *type,
    819                                    GLchar *name,
    820                                    angle::ParamCapture *paramCapture);
    821 void CaptureGetActiveUniform_size(const State &glState,
    822                                  bool isCallValid,
    823                                  ShaderProgramID programPacked,
    824                                  GLuint index,
    825                                  GLsizei bufSize,
    826                                  GLsizei *length,
    827                                  GLint *size,
    828                                  GLenum *type,
    829                                  GLchar *name,
    830                                  angle::ParamCapture *paramCapture);
    831 void CaptureGetActiveUniform_type(const State &glState,
    832                                  bool isCallValid,
    833                                  ShaderProgramID programPacked,
    834                                  GLuint index,
    835                                  GLsizei bufSize,
    836                                  GLsizei *length,
    837                                  GLint *size,
    838                                  GLenum *type,
    839                                  GLchar *name,
    840                                  angle::ParamCapture *paramCapture);
    841 void CaptureGetActiveUniform_name(const State &glState,
    842                                  bool isCallValid,
    843                                  ShaderProgramID programPacked,
    844                                  GLuint index,
    845                                  GLsizei bufSize,
    846                                  GLsizei *length,
    847                                  GLint *size,
    848                                  GLenum *type,
    849                                  GLchar *name,
    850                                  angle::ParamCapture *paramCapture);
    851 void CaptureGetAttachedShaders_count(const State &glState,
    852                                     bool isCallValid,
    853                                     ShaderProgramID programPacked,
    854                                     GLsizei maxCount,
    855                                     GLsizei *count,
    856                                     ShaderProgramID *shadersPacked,
    857                                     angle::ParamCapture *paramCapture);
    858 void CaptureGetAttachedShaders_shadersPacked(const State &glState,
    859                                             bool isCallValid,
    860                                             ShaderProgramID programPacked,
    861                                             GLsizei maxCount,
    862                                             GLsizei *count,
    863                                             ShaderProgramID *shadersPacked,
    864                                             angle::ParamCapture *paramCapture);
    865 void CaptureGetAttribLocation_name(const State &glState,
    866                                   bool isCallValid,
    867                                   ShaderProgramID programPacked,
    868                                   const GLchar *name,
    869                                   angle::ParamCapture *paramCapture);
    870 void CaptureGetBooleanv_data(const State &glState,
    871                             bool isCallValid,
    872                             GLenum pname,
    873                             GLboolean *data,
    874                             angle::ParamCapture *paramCapture);
    875 void CaptureGetBufferParameteriv_params(const State &glState,
    876                                        bool isCallValid,
    877                                        BufferBinding targetPacked,
    878                                        GLenum pname,
    879                                        GLint *params,
    880                                        angle::ParamCapture *paramCapture);
    881 void CaptureGetFloatv_data(const State &glState,
    882                           bool isCallValid,
    883                           GLenum pname,
    884                           GLfloat *data,
    885                           angle::ParamCapture *paramCapture);
    886 void CaptureGetFramebufferAttachmentParameteriv_params(const State &glState,
    887                                                       bool isCallValid,
    888                                                       GLenum target,
    889                                                       GLenum attachment,
    890                                                       GLenum pname,
    891                                                       GLint *params,
    892                                                       angle::ParamCapture *paramCapture);
    893 void CaptureGetIntegerv_data(const State &glState,
    894                             bool isCallValid,
    895                             GLenum pname,
    896                             GLint *data,
    897                             angle::ParamCapture *paramCapture);
    898 void CaptureGetProgramInfoLog_length(const State &glState,
    899                                     bool isCallValid,
    900                                     ShaderProgramID programPacked,
    901                                     GLsizei bufSize,
    902                                     GLsizei *length,
    903                                     GLchar *infoLog,
    904                                     angle::ParamCapture *paramCapture);
    905 void CaptureGetProgramInfoLog_infoLog(const State &glState,
    906                                      bool isCallValid,
    907                                      ShaderProgramID programPacked,
    908                                      GLsizei bufSize,
    909                                      GLsizei *length,
    910                                      GLchar *infoLog,
    911                                      angle::ParamCapture *paramCapture);
    912 void CaptureGetProgramiv_params(const State &glState,
    913                                bool isCallValid,
    914                                ShaderProgramID programPacked,
    915                                GLenum pname,
    916                                GLint *params,
    917                                angle::ParamCapture *paramCapture);
    918 void CaptureGetRenderbufferParameteriv_params(const State &glState,
    919                                              bool isCallValid,
    920                                              GLenum target,
    921                                              GLenum pname,
    922                                              GLint *params,
    923                                              angle::ParamCapture *paramCapture);
    924 void CaptureGetShaderInfoLog_length(const State &glState,
    925                                    bool isCallValid,
    926                                    ShaderProgramID shaderPacked,
    927                                    GLsizei bufSize,
    928                                    GLsizei *length,
    929                                    GLchar *infoLog,
    930                                    angle::ParamCapture *paramCapture);
    931 void CaptureGetShaderInfoLog_infoLog(const State &glState,
    932                                     bool isCallValid,
    933                                     ShaderProgramID shaderPacked,
    934                                     GLsizei bufSize,
    935                                     GLsizei *length,
    936                                     GLchar *infoLog,
    937                                     angle::ParamCapture *paramCapture);
    938 void CaptureGetShaderPrecisionFormat_range(const State &glState,
    939                                           bool isCallValid,
    940                                           GLenum shadertype,
    941                                           GLenum precisiontype,
    942                                           GLint *range,
    943                                           GLint *precision,
    944                                           angle::ParamCapture *paramCapture);
    945 void CaptureGetShaderPrecisionFormat_precision(const State &glState,
    946                                               bool isCallValid,
    947                                               GLenum shadertype,
    948                                               GLenum precisiontype,
    949                                               GLint *range,
    950                                               GLint *precision,
    951                                               angle::ParamCapture *paramCapture);
    952 void CaptureGetShaderSource_length(const State &glState,
    953                                   bool isCallValid,
    954                                   ShaderProgramID shaderPacked,
    955                                   GLsizei bufSize,
    956                                   GLsizei *length,
    957                                   GLchar *source,
    958                                   angle::ParamCapture *paramCapture);
    959 void CaptureGetShaderSource_source(const State &glState,
    960                                   bool isCallValid,
    961                                   ShaderProgramID shaderPacked,
    962                                   GLsizei bufSize,
    963                                   GLsizei *length,
    964                                   GLchar *source,
    965                                   angle::ParamCapture *paramCapture);
    966 void CaptureGetShaderiv_params(const State &glState,
    967                               bool isCallValid,
    968                               ShaderProgramID shaderPacked,
    969                               GLenum pname,
    970                               GLint *params,
    971                               angle::ParamCapture *paramCapture);
    972 void CaptureGetTexParameterfv_params(const State &glState,
    973                                     bool isCallValid,
    974                                     TextureType targetPacked,
    975                                     GLenum pname,
    976                                     GLfloat *params,
    977                                     angle::ParamCapture *paramCapture);
    978 void CaptureGetTexParameteriv_params(const State &glState,
    979                                     bool isCallValid,
    980                                     TextureType targetPacked,
    981                                     GLenum pname,
    982                                     GLint *params,
    983                                     angle::ParamCapture *paramCapture);
    984 void CaptureGetUniformLocation_name(const State &glState,
    985                                    bool isCallValid,
    986                                    ShaderProgramID programPacked,
    987                                    const GLchar *name,
    988                                    angle::ParamCapture *paramCapture);
    989 void CaptureGetUniformfv_params(const State &glState,
    990                                bool isCallValid,
    991                                ShaderProgramID programPacked,
    992                                UniformLocation locationPacked,
    993                                GLfloat *params,
    994                                angle::ParamCapture *paramCapture);
    995 void CaptureGetUniformiv_params(const State &glState,
    996                                bool isCallValid,
    997                                ShaderProgramID programPacked,
    998                                UniformLocation locationPacked,
    999                                GLint *params,
   1000                                angle::ParamCapture *paramCapture);
   1001 void CaptureGetVertexAttribPointerv_pointer(const State &glState,
   1002                                            bool isCallValid,
   1003                                            GLuint index,
   1004                                            GLenum pname,
   1005                                            void **pointer,
   1006                                            angle::ParamCapture *paramCapture);
   1007 void CaptureGetVertexAttribfv_params(const State &glState,
   1008                                     bool isCallValid,
   1009                                     GLuint index,
   1010                                     GLenum pname,
   1011                                     GLfloat *params,
   1012                                     angle::ParamCapture *paramCapture);
   1013 void CaptureGetVertexAttribiv_params(const State &glState,
   1014                                     bool isCallValid,
   1015                                     GLuint index,
   1016                                     GLenum pname,
   1017                                     GLint *params,
   1018                                     angle::ParamCapture *paramCapture);
   1019 void CaptureReadPixels_pixels(const State &glState,
   1020                              bool isCallValid,
   1021                              GLint x,
   1022                              GLint y,
   1023                              GLsizei width,
   1024                              GLsizei height,
   1025                              GLenum format,
   1026                              GLenum type,
   1027                              void *pixels,
   1028                              angle::ParamCapture *paramCapture);
   1029 void CaptureShaderBinary_shadersPacked(const State &glState,
   1030                                       bool isCallValid,
   1031                                       GLsizei count,
   1032                                       const ShaderProgramID *shadersPacked,
   1033                                       GLenum binaryFormat,
   1034                                       const void *binary,
   1035                                       GLsizei length,
   1036                                       angle::ParamCapture *paramCapture);
   1037 void CaptureShaderBinary_binary(const State &glState,
   1038                                bool isCallValid,
   1039                                GLsizei count,
   1040                                const ShaderProgramID *shadersPacked,
   1041                                GLenum binaryFormat,
   1042                                const void *binary,
   1043                                GLsizei length,
   1044                                angle::ParamCapture *paramCapture);
   1045 void CaptureShaderSource_string(const State &glState,
   1046                                bool isCallValid,
   1047                                ShaderProgramID shaderPacked,
   1048                                GLsizei count,
   1049                                const GLchar *const *string,
   1050                                const GLint *length,
   1051                                angle::ParamCapture *paramCapture);
   1052 void CaptureShaderSource_length(const State &glState,
   1053                                bool isCallValid,
   1054                                ShaderProgramID shaderPacked,
   1055                                GLsizei count,
   1056                                const GLchar *const *string,
   1057                                const GLint *length,
   1058                                angle::ParamCapture *paramCapture);
   1059 void CaptureTexImage2D_pixels(const State &glState,
   1060                              bool isCallValid,
   1061                              TextureTarget targetPacked,
   1062                              GLint level,
   1063                              GLint internalformat,
   1064                              GLsizei width,
   1065                              GLsizei height,
   1066                              GLint border,
   1067                              GLenum format,
   1068                              GLenum type,
   1069                              const void *pixels,
   1070                              angle::ParamCapture *paramCapture);
   1071 void CaptureTexParameterfv_params(const State &glState,
   1072                                  bool isCallValid,
   1073                                  TextureType targetPacked,
   1074                                  GLenum pname,
   1075                                  const GLfloat *params,
   1076                                  angle::ParamCapture *paramCapture);
   1077 void CaptureTexParameteriv_params(const State &glState,
   1078                                  bool isCallValid,
   1079                                  TextureType targetPacked,
   1080                                  GLenum pname,
   1081                                  const GLint *params,
   1082                                  angle::ParamCapture *paramCapture);
   1083 void CaptureTexSubImage2D_pixels(const State &glState,
   1084                                 bool isCallValid,
   1085                                 TextureTarget targetPacked,
   1086                                 GLint level,
   1087                                 GLint xoffset,
   1088                                 GLint yoffset,
   1089                                 GLsizei width,
   1090                                 GLsizei height,
   1091                                 GLenum format,
   1092                                 GLenum type,
   1093                                 const void *pixels,
   1094                                 angle::ParamCapture *paramCapture);
   1095 void CaptureUniform1fv_value(const State &glState,
   1096                             bool isCallValid,
   1097                             UniformLocation locationPacked,
   1098                             GLsizei count,
   1099                             const GLfloat *value,
   1100                             angle::ParamCapture *paramCapture);
   1101 void CaptureUniform1iv_value(const State &glState,
   1102                             bool isCallValid,
   1103                             UniformLocation locationPacked,
   1104                             GLsizei count,
   1105                             const GLint *value,
   1106                             angle::ParamCapture *paramCapture);
   1107 void CaptureUniform2fv_value(const State &glState,
   1108                             bool isCallValid,
   1109                             UniformLocation locationPacked,
   1110                             GLsizei count,
   1111                             const GLfloat *value,
   1112                             angle::ParamCapture *paramCapture);
   1113 void CaptureUniform2iv_value(const State &glState,
   1114                             bool isCallValid,
   1115                             UniformLocation locationPacked,
   1116                             GLsizei count,
   1117                             const GLint *value,
   1118                             angle::ParamCapture *paramCapture);
   1119 void CaptureUniform3fv_value(const State &glState,
   1120                             bool isCallValid,
   1121                             UniformLocation locationPacked,
   1122                             GLsizei count,
   1123                             const GLfloat *value,
   1124                             angle::ParamCapture *paramCapture);
   1125 void CaptureUniform3iv_value(const State &glState,
   1126                             bool isCallValid,
   1127                             UniformLocation locationPacked,
   1128                             GLsizei count,
   1129                             const GLint *value,
   1130                             angle::ParamCapture *paramCapture);
   1131 void CaptureUniform4fv_value(const State &glState,
   1132                             bool isCallValid,
   1133                             UniformLocation locationPacked,
   1134                             GLsizei count,
   1135                             const GLfloat *value,
   1136                             angle::ParamCapture *paramCapture);
   1137 void CaptureUniform4iv_value(const State &glState,
   1138                             bool isCallValid,
   1139                             UniformLocation locationPacked,
   1140                             GLsizei count,
   1141                             const GLint *value,
   1142                             angle::ParamCapture *paramCapture);
   1143 void CaptureUniformMatrix2fv_value(const State &glState,
   1144                                   bool isCallValid,
   1145                                   UniformLocation locationPacked,
   1146                                   GLsizei count,
   1147                                   GLboolean transpose,
   1148                                   const GLfloat *value,
   1149                                   angle::ParamCapture *paramCapture);
   1150 void CaptureUniformMatrix3fv_value(const State &glState,
   1151                                   bool isCallValid,
   1152                                   UniformLocation locationPacked,
   1153                                   GLsizei count,
   1154                                   GLboolean transpose,
   1155                                   const GLfloat *value,
   1156                                   angle::ParamCapture *paramCapture);
   1157 void CaptureUniformMatrix4fv_value(const State &glState,
   1158                                   bool isCallValid,
   1159                                   UniformLocation locationPacked,
   1160                                   GLsizei count,
   1161                                   GLboolean transpose,
   1162                                   const GLfloat *value,
   1163                                   angle::ParamCapture *paramCapture);
   1164 void CaptureVertexAttrib1fv_v(const State &glState,
   1165                              bool isCallValid,
   1166                              GLuint index,
   1167                              const GLfloat *v,
   1168                              angle::ParamCapture *paramCapture);
   1169 void CaptureVertexAttrib2fv_v(const State &glState,
   1170                              bool isCallValid,
   1171                              GLuint index,
   1172                              const GLfloat *v,
   1173                              angle::ParamCapture *paramCapture);
   1174 void CaptureVertexAttrib3fv_v(const State &glState,
   1175                              bool isCallValid,
   1176                              GLuint index,
   1177                              const GLfloat *v,
   1178                              angle::ParamCapture *paramCapture);
   1179 void CaptureVertexAttrib4fv_v(const State &glState,
   1180                              bool isCallValid,
   1181                              GLuint index,
   1182                              const GLfloat *v,
   1183                              angle::ParamCapture *paramCapture);
   1184 void CaptureVertexAttribPointer_pointer(const State &glState,
   1185                                        bool isCallValid,
   1186                                        GLuint index,
   1187                                        GLint size,
   1188                                        VertexAttribType typePacked,
   1189                                        GLboolean normalized,
   1190                                        GLsizei stride,
   1191                                        const void *pointer,
   1192                                        angle::ParamCapture *paramCapture);
   1193 }  // namespace gl
   1194 
   1195 #endif  // LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_