tor-browser

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

capture_gl_4_autogen.h (159791B)


      1 // GENERATED FILE - DO NOT EDIT.
      2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
      3 //
      4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
      5 // Use of this source code is governed by a BSD-style license that can be
      6 // found in the LICENSE file.
      7 //
      8 // capture_gl_4_autogen.h:
      9 //   Capture functions for the OpenGL ES Desktop GL 4.x entry points.
     10 
     11 #ifndef LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_
     12 #define LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_
     13 
     14 #include "common/PackedEnums.h"
     15 #include "libANGLE/capture/FrameCapture.h"
     16 
     17 namespace gl
     18 {
     19 
     20 // Method Captures
     21 
     22 // GL 4.0
     23 angle::CallCapture CaptureBeginQueryIndexed(const State &glState,
     24                                            bool isCallValid,
     25                                            GLenum target,
     26                                            GLuint index,
     27                                            QueryID idPacked);
     28 angle::CallCapture CaptureDrawTransformFeedback(const State &glState,
     29                                                bool isCallValid,
     30                                                GLenum mode,
     31                                                TransformFeedbackID idPacked);
     32 angle::CallCapture CaptureDrawTransformFeedbackStream(const State &glState,
     33                                                      bool isCallValid,
     34                                                      GLenum mode,
     35                                                      TransformFeedbackID idPacked,
     36                                                      GLuint stream);
     37 angle::CallCapture CaptureEndQueryIndexed(const State &glState,
     38                                          bool isCallValid,
     39                                          GLenum target,
     40                                          GLuint index);
     41 angle::CallCapture CaptureGetActiveSubroutineName(const State &glState,
     42                                                  bool isCallValid,
     43                                                  ShaderProgramID programPacked,
     44                                                  GLenum shadertype,
     45                                                  GLuint index,
     46                                                  GLsizei bufSize,
     47                                                  GLsizei *length,
     48                                                  GLchar *name);
     49 angle::CallCapture CaptureGetActiveSubroutineUniformName(const State &glState,
     50                                                         bool isCallValid,
     51                                                         ShaderProgramID programPacked,
     52                                                         GLenum shadertype,
     53                                                         GLuint index,
     54                                                         GLsizei bufSize,
     55                                                         GLsizei *length,
     56                                                         GLchar *name);
     57 angle::CallCapture CaptureGetActiveSubroutineUniformiv(const State &glState,
     58                                                       bool isCallValid,
     59                                                       ShaderProgramID programPacked,
     60                                                       GLenum shadertype,
     61                                                       GLuint index,
     62                                                       GLenum pname,
     63                                                       GLint *values);
     64 angle::CallCapture CaptureGetProgramStageiv(const State &glState,
     65                                            bool isCallValid,
     66                                            ShaderProgramID programPacked,
     67                                            GLenum shadertype,
     68                                            GLenum pname,
     69                                            GLint *values);
     70 angle::CallCapture CaptureGetQueryIndexediv(const State &glState,
     71                                            bool isCallValid,
     72                                            GLenum target,
     73                                            GLuint index,
     74                                            GLenum pname,
     75                                            GLint *params);
     76 angle::CallCapture CaptureGetSubroutineIndex(const State &glState,
     77                                             bool isCallValid,
     78                                             ShaderProgramID programPacked,
     79                                             GLenum shadertype,
     80                                             const GLchar *name,
     81                                             GLuint returnValue);
     82 angle::CallCapture CaptureGetSubroutineUniformLocation(const State &glState,
     83                                                       bool isCallValid,
     84                                                       ShaderProgramID programPacked,
     85                                                       GLenum shadertype,
     86                                                       const GLchar *name,
     87                                                       GLint returnValue);
     88 angle::CallCapture CaptureGetUniformSubroutineuiv(const State &glState,
     89                                                  bool isCallValid,
     90                                                  GLenum shadertype,
     91                                                  GLint location,
     92                                                  GLuint *params);
     93 angle::CallCapture CaptureGetUniformdv(const State &glState,
     94                                       bool isCallValid,
     95                                       ShaderProgramID programPacked,
     96                                       UniformLocation locationPacked,
     97                                       GLdouble *params);
     98 angle::CallCapture CapturePatchParameterfv(const State &glState,
     99                                           bool isCallValid,
    100                                           GLenum pname,
    101                                           const GLfloat *values);
    102 angle::CallCapture CaptureUniform1d(const State &glState,
    103                                    bool isCallValid,
    104                                    UniformLocation locationPacked,
    105                                    GLdouble x);
    106 angle::CallCapture CaptureUniform1dv(const State &glState,
    107                                     bool isCallValid,
    108                                     UniformLocation locationPacked,
    109                                     GLsizei count,
    110                                     const GLdouble *value);
    111 angle::CallCapture CaptureUniform2d(const State &glState,
    112                                    bool isCallValid,
    113                                    UniformLocation locationPacked,
    114                                    GLdouble x,
    115                                    GLdouble y);
    116 angle::CallCapture CaptureUniform2dv(const State &glState,
    117                                     bool isCallValid,
    118                                     UniformLocation locationPacked,
    119                                     GLsizei count,
    120                                     const GLdouble *value);
    121 angle::CallCapture CaptureUniform3d(const State &glState,
    122                                    bool isCallValid,
    123                                    UniformLocation locationPacked,
    124                                    GLdouble x,
    125                                    GLdouble y,
    126                                    GLdouble z);
    127 angle::CallCapture CaptureUniform3dv(const State &glState,
    128                                     bool isCallValid,
    129                                     UniformLocation locationPacked,
    130                                     GLsizei count,
    131                                     const GLdouble *value);
    132 angle::CallCapture CaptureUniform4d(const State &glState,
    133                                    bool isCallValid,
    134                                    UniformLocation locationPacked,
    135                                    GLdouble x,
    136                                    GLdouble y,
    137                                    GLdouble z,
    138                                    GLdouble w);
    139 angle::CallCapture CaptureUniform4dv(const State &glState,
    140                                     bool isCallValid,
    141                                     UniformLocation locationPacked,
    142                                     GLsizei count,
    143                                     const GLdouble *value);
    144 angle::CallCapture CaptureUniformMatrix2dv(const State &glState,
    145                                           bool isCallValid,
    146                                           UniformLocation locationPacked,
    147                                           GLsizei count,
    148                                           GLboolean transpose,
    149                                           const GLdouble *value);
    150 angle::CallCapture CaptureUniformMatrix2x3dv(const State &glState,
    151                                             bool isCallValid,
    152                                             UniformLocation locationPacked,
    153                                             GLsizei count,
    154                                             GLboolean transpose,
    155                                             const GLdouble *value);
    156 angle::CallCapture CaptureUniformMatrix2x4dv(const State &glState,
    157                                             bool isCallValid,
    158                                             UniformLocation locationPacked,
    159                                             GLsizei count,
    160                                             GLboolean transpose,
    161                                             const GLdouble *value);
    162 angle::CallCapture CaptureUniformMatrix3dv(const State &glState,
    163                                           bool isCallValid,
    164                                           UniformLocation locationPacked,
    165                                           GLsizei count,
    166                                           GLboolean transpose,
    167                                           const GLdouble *value);
    168 angle::CallCapture CaptureUniformMatrix3x2dv(const State &glState,
    169                                             bool isCallValid,
    170                                             UniformLocation locationPacked,
    171                                             GLsizei count,
    172                                             GLboolean transpose,
    173                                             const GLdouble *value);
    174 angle::CallCapture CaptureUniformMatrix3x4dv(const State &glState,
    175                                             bool isCallValid,
    176                                             UniformLocation locationPacked,
    177                                             GLsizei count,
    178                                             GLboolean transpose,
    179                                             const GLdouble *value);
    180 angle::CallCapture CaptureUniformMatrix4dv(const State &glState,
    181                                           bool isCallValid,
    182                                           UniformLocation locationPacked,
    183                                           GLsizei count,
    184                                           GLboolean transpose,
    185                                           const GLdouble *value);
    186 angle::CallCapture CaptureUniformMatrix4x2dv(const State &glState,
    187                                             bool isCallValid,
    188                                             UniformLocation locationPacked,
    189                                             GLsizei count,
    190                                             GLboolean transpose,
    191                                             const GLdouble *value);
    192 angle::CallCapture CaptureUniformMatrix4x3dv(const State &glState,
    193                                             bool isCallValid,
    194                                             UniformLocation locationPacked,
    195                                             GLsizei count,
    196                                             GLboolean transpose,
    197                                             const GLdouble *value);
    198 angle::CallCapture CaptureUniformSubroutinesuiv(const State &glState,
    199                                                bool isCallValid,
    200                                                GLenum shadertype,
    201                                                GLsizei count,
    202                                                const GLuint *indices);
    203 
    204 // GL 4.1
    205 angle::CallCapture CaptureDepthRangeArrayv(const State &glState,
    206                                           bool isCallValid,
    207                                           GLuint first,
    208                                           GLsizei count,
    209                                           const GLdouble *v);
    210 angle::CallCapture CaptureDepthRangeIndexed(const State &glState,
    211                                            bool isCallValid,
    212                                            GLuint index,
    213                                            GLdouble n,
    214                                            GLdouble f);
    215 angle::CallCapture CaptureGetDoublei_v(const State &glState,
    216                                       bool isCallValid,
    217                                       GLenum target,
    218                                       GLuint index,
    219                                       GLdouble *data);
    220 angle::CallCapture CaptureGetFloati_v(const State &glState,
    221                                      bool isCallValid,
    222                                      GLenum target,
    223                                      GLuint index,
    224                                      GLfloat *data);
    225 angle::CallCapture CaptureGetVertexAttribLdv(const State &glState,
    226                                             bool isCallValid,
    227                                             GLuint index,
    228                                             GLenum pname,
    229                                             GLdouble *params);
    230 angle::CallCapture CaptureProgramUniform1d(const State &glState,
    231                                           bool isCallValid,
    232                                           ShaderProgramID programPacked,
    233                                           UniformLocation locationPacked,
    234                                           GLdouble v0);
    235 angle::CallCapture CaptureProgramUniform1dv(const State &glState,
    236                                            bool isCallValid,
    237                                            ShaderProgramID programPacked,
    238                                            UniformLocation locationPacked,
    239                                            GLsizei count,
    240                                            const GLdouble *value);
    241 angle::CallCapture CaptureProgramUniform2d(const State &glState,
    242                                           bool isCallValid,
    243                                           ShaderProgramID programPacked,
    244                                           UniformLocation locationPacked,
    245                                           GLdouble v0,
    246                                           GLdouble v1);
    247 angle::CallCapture CaptureProgramUniform2dv(const State &glState,
    248                                            bool isCallValid,
    249                                            ShaderProgramID programPacked,
    250                                            UniformLocation locationPacked,
    251                                            GLsizei count,
    252                                            const GLdouble *value);
    253 angle::CallCapture CaptureProgramUniform3d(const State &glState,
    254                                           bool isCallValid,
    255                                           ShaderProgramID programPacked,
    256                                           UniformLocation locationPacked,
    257                                           GLdouble v0,
    258                                           GLdouble v1,
    259                                           GLdouble v2);
    260 angle::CallCapture CaptureProgramUniform3dv(const State &glState,
    261                                            bool isCallValid,
    262                                            ShaderProgramID programPacked,
    263                                            UniformLocation locationPacked,
    264                                            GLsizei count,
    265                                            const GLdouble *value);
    266 angle::CallCapture CaptureProgramUniform4d(const State &glState,
    267                                           bool isCallValid,
    268                                           ShaderProgramID programPacked,
    269                                           UniformLocation locationPacked,
    270                                           GLdouble v0,
    271                                           GLdouble v1,
    272                                           GLdouble v2,
    273                                           GLdouble v3);
    274 angle::CallCapture CaptureProgramUniform4dv(const State &glState,
    275                                            bool isCallValid,
    276                                            ShaderProgramID programPacked,
    277                                            UniformLocation locationPacked,
    278                                            GLsizei count,
    279                                            const GLdouble *value);
    280 angle::CallCapture CaptureProgramUniformMatrix2dv(const State &glState,
    281                                                  bool isCallValid,
    282                                                  ShaderProgramID programPacked,
    283                                                  UniformLocation locationPacked,
    284                                                  GLsizei count,
    285                                                  GLboolean transpose,
    286                                                  const GLdouble *value);
    287 angle::CallCapture CaptureProgramUniformMatrix2x3dv(const State &glState,
    288                                                    bool isCallValid,
    289                                                    ShaderProgramID programPacked,
    290                                                    UniformLocation locationPacked,
    291                                                    GLsizei count,
    292                                                    GLboolean transpose,
    293                                                    const GLdouble *value);
    294 angle::CallCapture CaptureProgramUniformMatrix2x4dv(const State &glState,
    295                                                    bool isCallValid,
    296                                                    ShaderProgramID programPacked,
    297                                                    UniformLocation locationPacked,
    298                                                    GLsizei count,
    299                                                    GLboolean transpose,
    300                                                    const GLdouble *value);
    301 angle::CallCapture CaptureProgramUniformMatrix3dv(const State &glState,
    302                                                  bool isCallValid,
    303                                                  ShaderProgramID programPacked,
    304                                                  UniformLocation locationPacked,
    305                                                  GLsizei count,
    306                                                  GLboolean transpose,
    307                                                  const GLdouble *value);
    308 angle::CallCapture CaptureProgramUniformMatrix3x2dv(const State &glState,
    309                                                    bool isCallValid,
    310                                                    ShaderProgramID programPacked,
    311                                                    UniformLocation locationPacked,
    312                                                    GLsizei count,
    313                                                    GLboolean transpose,
    314                                                    const GLdouble *value);
    315 angle::CallCapture CaptureProgramUniformMatrix3x4dv(const State &glState,
    316                                                    bool isCallValid,
    317                                                    ShaderProgramID programPacked,
    318                                                    UniformLocation locationPacked,
    319                                                    GLsizei count,
    320                                                    GLboolean transpose,
    321                                                    const GLdouble *value);
    322 angle::CallCapture CaptureProgramUniformMatrix4dv(const State &glState,
    323                                                  bool isCallValid,
    324                                                  ShaderProgramID programPacked,
    325                                                  UniformLocation locationPacked,
    326                                                  GLsizei count,
    327                                                  GLboolean transpose,
    328                                                  const GLdouble *value);
    329 angle::CallCapture CaptureProgramUniformMatrix4x2dv(const State &glState,
    330                                                    bool isCallValid,
    331                                                    ShaderProgramID programPacked,
    332                                                    UniformLocation locationPacked,
    333                                                    GLsizei count,
    334                                                    GLboolean transpose,
    335                                                    const GLdouble *value);
    336 angle::CallCapture CaptureProgramUniformMatrix4x3dv(const State &glState,
    337                                                    bool isCallValid,
    338                                                    ShaderProgramID programPacked,
    339                                                    UniformLocation locationPacked,
    340                                                    GLsizei count,
    341                                                    GLboolean transpose,
    342                                                    const GLdouble *value);
    343 angle::CallCapture CaptureScissorArrayv(const State &glState,
    344                                        bool isCallValid,
    345                                        GLuint first,
    346                                        GLsizei count,
    347                                        const GLint *v);
    348 angle::CallCapture CaptureScissorIndexed(const State &glState,
    349                                         bool isCallValid,
    350                                         GLuint index,
    351                                         GLint left,
    352                                         GLint bottom,
    353                                         GLsizei width,
    354                                         GLsizei height);
    355 angle::CallCapture CaptureScissorIndexedv(const State &glState,
    356                                          bool isCallValid,
    357                                          GLuint index,
    358                                          const GLint *v);
    359 angle::CallCapture CaptureVertexAttribL1d(const State &glState,
    360                                          bool isCallValid,
    361                                          GLuint index,
    362                                          GLdouble x);
    363 angle::CallCapture CaptureVertexAttribL1dv(const State &glState,
    364                                           bool isCallValid,
    365                                           GLuint index,
    366                                           const GLdouble *v);
    367 angle::CallCapture CaptureVertexAttribL2d(const State &glState,
    368                                          bool isCallValid,
    369                                          GLuint index,
    370                                          GLdouble x,
    371                                          GLdouble y);
    372 angle::CallCapture CaptureVertexAttribL2dv(const State &glState,
    373                                           bool isCallValid,
    374                                           GLuint index,
    375                                           const GLdouble *v);
    376 angle::CallCapture CaptureVertexAttribL3d(const State &glState,
    377                                          bool isCallValid,
    378                                          GLuint index,
    379                                          GLdouble x,
    380                                          GLdouble y,
    381                                          GLdouble z);
    382 angle::CallCapture CaptureVertexAttribL3dv(const State &glState,
    383                                           bool isCallValid,
    384                                           GLuint index,
    385                                           const GLdouble *v);
    386 angle::CallCapture CaptureVertexAttribL4d(const State &glState,
    387                                          bool isCallValid,
    388                                          GLuint index,
    389                                          GLdouble x,
    390                                          GLdouble y,
    391                                          GLdouble z,
    392                                          GLdouble w);
    393 angle::CallCapture CaptureVertexAttribL4dv(const State &glState,
    394                                           bool isCallValid,
    395                                           GLuint index,
    396                                           const GLdouble *v);
    397 angle::CallCapture CaptureVertexAttribLPointer(const State &glState,
    398                                               bool isCallValid,
    399                                               GLuint index,
    400                                               GLint size,
    401                                               GLenum type,
    402                                               GLsizei stride,
    403                                               const void *pointer);
    404 angle::CallCapture CaptureViewportArrayv(const State &glState,
    405                                         bool isCallValid,
    406                                         GLuint first,
    407                                         GLsizei count,
    408                                         const GLfloat *v);
    409 angle::CallCapture CaptureViewportIndexedf(const State &glState,
    410                                           bool isCallValid,
    411                                           GLuint index,
    412                                           GLfloat x,
    413                                           GLfloat y,
    414                                           GLfloat w,
    415                                           GLfloat h);
    416 angle::CallCapture CaptureViewportIndexedfv(const State &glState,
    417                                            bool isCallValid,
    418                                            GLuint index,
    419                                            const GLfloat *v);
    420 
    421 // GL 4.2
    422 angle::CallCapture CaptureDrawArraysInstancedBaseInstance(const State &glState,
    423                                                          bool isCallValid,
    424                                                          PrimitiveMode modePacked,
    425                                                          GLint first,
    426                                                          GLsizei count,
    427                                                          GLsizei instancecount,
    428                                                          GLuint baseinstance);
    429 angle::CallCapture CaptureDrawElementsInstancedBaseInstance(const State &glState,
    430                                                            bool isCallValid,
    431                                                            PrimitiveMode modePacked,
    432                                                            GLsizei count,
    433                                                            DrawElementsType typePacked,
    434                                                            const void *indices,
    435                                                            GLsizei instancecount,
    436                                                            GLuint baseinstance);
    437 angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstance(const State &glState,
    438                                                                      bool isCallValid,
    439                                                                      PrimitiveMode modePacked,
    440                                                                      GLsizei count,
    441                                                                      DrawElementsType typePacked,
    442                                                                      const void *indices,
    443                                                                      GLsizei instancecount,
    444                                                                      GLint basevertex,
    445                                                                      GLuint baseinstance);
    446 angle::CallCapture CaptureDrawTransformFeedbackInstanced(const State &glState,
    447                                                         bool isCallValid,
    448                                                         GLenum mode,
    449                                                         TransformFeedbackID idPacked,
    450                                                         GLsizei instancecount);
    451 angle::CallCapture CaptureDrawTransformFeedbackStreamInstanced(const State &glState,
    452                                                               bool isCallValid,
    453                                                               GLenum mode,
    454                                                               TransformFeedbackID idPacked,
    455                                                               GLuint stream,
    456                                                               GLsizei instancecount);
    457 angle::CallCapture CaptureGetActiveAtomicCounterBufferiv(const State &glState,
    458                                                         bool isCallValid,
    459                                                         ShaderProgramID programPacked,
    460                                                         GLuint bufferIndex,
    461                                                         GLenum pname,
    462                                                         GLint *params);
    463 angle::CallCapture CaptureTexStorage1D(const State &glState,
    464                                       bool isCallValid,
    465                                       GLenum target,
    466                                       GLsizei levels,
    467                                       GLenum internalformat,
    468                                       GLsizei width);
    469 
    470 // GL 4.3
    471 angle::CallCapture CaptureClearBufferData(const State &glState,
    472                                          bool isCallValid,
    473                                          GLenum target,
    474                                          GLenum internalformat,
    475                                          GLenum format,
    476                                          GLenum type,
    477                                          const void *data);
    478 angle::CallCapture CaptureClearBufferSubData(const State &glState,
    479                                             bool isCallValid,
    480                                             GLenum target,
    481                                             GLenum internalformat,
    482                                             GLintptr offset,
    483                                             GLsizeiptr size,
    484                                             GLenum format,
    485                                             GLenum type,
    486                                             const void *data);
    487 angle::CallCapture CaptureGetInternalformati64v(const State &glState,
    488                                                bool isCallValid,
    489                                                GLenum target,
    490                                                GLenum internalformat,
    491                                                GLenum pname,
    492                                                GLsizei count,
    493                                                GLint64 *params);
    494 angle::CallCapture CaptureGetProgramResourceLocationIndex(const State &glState,
    495                                                          bool isCallValid,
    496                                                          ShaderProgramID programPacked,
    497                                                          GLenum programInterface,
    498                                                          const GLchar *name,
    499                                                          GLint returnValue);
    500 angle::CallCapture CaptureInvalidateBufferData(const State &glState,
    501                                               bool isCallValid,
    502                                               BufferID bufferPacked);
    503 angle::CallCapture CaptureInvalidateBufferSubData(const State &glState,
    504                                                  bool isCallValid,
    505                                                  BufferID bufferPacked,
    506                                                  GLintptr offset,
    507                                                  GLsizeiptr length);
    508 angle::CallCapture CaptureInvalidateTexImage(const State &glState,
    509                                             bool isCallValid,
    510                                             TextureID texturePacked,
    511                                             GLint level);
    512 angle::CallCapture CaptureInvalidateTexSubImage(const State &glState,
    513                                                bool isCallValid,
    514                                                TextureID texturePacked,
    515                                                GLint level,
    516                                                GLint xoffset,
    517                                                GLint yoffset,
    518                                                GLint zoffset,
    519                                                GLsizei width,
    520                                                GLsizei height,
    521                                                GLsizei depth);
    522 angle::CallCapture CaptureMultiDrawArraysIndirect(const State &glState,
    523                                                  bool isCallValid,
    524                                                  PrimitiveMode modePacked,
    525                                                  const void *indirect,
    526                                                  GLsizei drawcount,
    527                                                  GLsizei stride);
    528 angle::CallCapture CaptureMultiDrawElementsIndirect(const State &glState,
    529                                                    bool isCallValid,
    530                                                    PrimitiveMode modePacked,
    531                                                    DrawElementsType typePacked,
    532                                                    const void *indirect,
    533                                                    GLsizei drawcount,
    534                                                    GLsizei stride);
    535 angle::CallCapture CaptureShaderStorageBlockBinding(const State &glState,
    536                                                    bool isCallValid,
    537                                                    ShaderProgramID programPacked,
    538                                                    GLuint storageBlockIndex,
    539                                                    GLuint storageBlockBinding);
    540 angle::CallCapture CaptureTextureView(const State &glState,
    541                                      bool isCallValid,
    542                                      TextureID texturePacked,
    543                                      GLenum target,
    544                                      GLuint origtexture,
    545                                      GLenum internalformat,
    546                                      GLuint minlevel,
    547                                      GLuint numlevels,
    548                                      GLuint minlayer,
    549                                      GLuint numlayers);
    550 angle::CallCapture CaptureVertexAttribLFormat(const State &glState,
    551                                              bool isCallValid,
    552                                              GLuint attribindex,
    553                                              GLint size,
    554                                              GLenum type,
    555                                              GLuint relativeoffset);
    556 
    557 // GL 4.4
    558 angle::CallCapture CaptureBindBuffersBase(const State &glState,
    559                                          bool isCallValid,
    560                                          GLenum target,
    561                                          GLuint first,
    562                                          GLsizei count,
    563                                          const BufferID *buffersPacked);
    564 angle::CallCapture CaptureBindBuffersRange(const State &glState,
    565                                           bool isCallValid,
    566                                           GLenum target,
    567                                           GLuint first,
    568                                           GLsizei count,
    569                                           const BufferID *buffersPacked,
    570                                           const GLintptr *offsets,
    571                                           const GLsizeiptr *sizes);
    572 angle::CallCapture CaptureBindImageTextures(const State &glState,
    573                                            bool isCallValid,
    574                                            GLuint first,
    575                                            GLsizei count,
    576                                            const GLuint *textures);
    577 angle::CallCapture CaptureBindSamplers(const State &glState,
    578                                       bool isCallValid,
    579                                       GLuint first,
    580                                       GLsizei count,
    581                                       const GLuint *samplers);
    582 angle::CallCapture CaptureBindTextures(const State &glState,
    583                                       bool isCallValid,
    584                                       GLuint first,
    585                                       GLsizei count,
    586                                       const GLuint *textures);
    587 angle::CallCapture CaptureBindVertexBuffers(const State &glState,
    588                                            bool isCallValid,
    589                                            GLuint first,
    590                                            GLsizei count,
    591                                            const BufferID *buffersPacked,
    592                                            const GLintptr *offsets,
    593                                            const GLsizei *strides);
    594 angle::CallCapture CaptureBufferStorage(const State &glState,
    595                                        bool isCallValid,
    596                                        BufferBinding targetPacked,
    597                                        GLsizeiptr size,
    598                                        const void *data,
    599                                        GLbitfield flags);
    600 angle::CallCapture CaptureClearTexImage(const State &glState,
    601                                        bool isCallValid,
    602                                        TextureID texturePacked,
    603                                        GLint level,
    604                                        GLenum format,
    605                                        GLenum type,
    606                                        const void *data);
    607 angle::CallCapture CaptureClearTexSubImage(const State &glState,
    608                                           bool isCallValid,
    609                                           TextureID texturePacked,
    610                                           GLint level,
    611                                           GLint xoffset,
    612                                           GLint yoffset,
    613                                           GLint zoffset,
    614                                           GLsizei width,
    615                                           GLsizei height,
    616                                           GLsizei depth,
    617                                           GLenum format,
    618                                           GLenum type,
    619                                           const void *data);
    620 
    621 // GL 4.5
    622 angle::CallCapture CaptureBindTextureUnit(const State &glState,
    623                                          bool isCallValid,
    624                                          GLuint unit,
    625                                          TextureID texturePacked);
    626 angle::CallCapture CaptureBlitNamedFramebuffer(const State &glState,
    627                                               bool isCallValid,
    628                                               GLuint readFramebuffer,
    629                                               GLuint drawFramebuffer,
    630                                               GLint srcX0,
    631                                               GLint srcY0,
    632                                               GLint srcX1,
    633                                               GLint srcY1,
    634                                               GLint dstX0,
    635                                               GLint dstY0,
    636                                               GLint dstX1,
    637                                               GLint dstY1,
    638                                               GLbitfield mask,
    639                                               GLenum filter);
    640 angle::CallCapture CaptureCheckNamedFramebufferStatus(const State &glState,
    641                                                      bool isCallValid,
    642                                                      FramebufferID framebufferPacked,
    643                                                      GLenum target,
    644                                                      GLenum returnValue);
    645 angle::CallCapture CaptureClearNamedBufferData(const State &glState,
    646                                               bool isCallValid,
    647                                               BufferID bufferPacked,
    648                                               GLenum internalformat,
    649                                               GLenum format,
    650                                               GLenum type,
    651                                               const void *data);
    652 angle::CallCapture CaptureClearNamedBufferSubData(const State &glState,
    653                                                  bool isCallValid,
    654                                                  BufferID bufferPacked,
    655                                                  GLenum internalformat,
    656                                                  GLintptr offset,
    657                                                  GLsizeiptr size,
    658                                                  GLenum format,
    659                                                  GLenum type,
    660                                                  const void *data);
    661 angle::CallCapture CaptureClearNamedFramebufferfi(const State &glState,
    662                                                  bool isCallValid,
    663                                                  FramebufferID framebufferPacked,
    664                                                  GLenum buffer,
    665                                                  GLint drawbuffer,
    666                                                  GLfloat depth,
    667                                                  GLint stencil);
    668 angle::CallCapture CaptureClearNamedFramebufferfv(const State &glState,
    669                                                  bool isCallValid,
    670                                                  FramebufferID framebufferPacked,
    671                                                  GLenum buffer,
    672                                                  GLint drawbuffer,
    673                                                  const GLfloat *value);
    674 angle::CallCapture CaptureClearNamedFramebufferiv(const State &glState,
    675                                                  bool isCallValid,
    676                                                  FramebufferID framebufferPacked,
    677                                                  GLenum buffer,
    678                                                  GLint drawbuffer,
    679                                                  const GLint *value);
    680 angle::CallCapture CaptureClearNamedFramebufferuiv(const State &glState,
    681                                                   bool isCallValid,
    682                                                   FramebufferID framebufferPacked,
    683                                                   GLenum buffer,
    684                                                   GLint drawbuffer,
    685                                                   const GLuint *value);
    686 angle::CallCapture CaptureClipControl(const State &glState,
    687                                      bool isCallValid,
    688                                      GLenum origin,
    689                                      GLenum depth);
    690 angle::CallCapture CaptureCompressedTextureSubImage1D(const State &glState,
    691                                                      bool isCallValid,
    692                                                      TextureID texturePacked,
    693                                                      GLint level,
    694                                                      GLint xoffset,
    695                                                      GLsizei width,
    696                                                      GLenum format,
    697                                                      GLsizei imageSize,
    698                                                      const void *data);
    699 angle::CallCapture CaptureCompressedTextureSubImage2D(const State &glState,
    700                                                      bool isCallValid,
    701                                                      TextureID texturePacked,
    702                                                      GLint level,
    703                                                      GLint xoffset,
    704                                                      GLint yoffset,
    705                                                      GLsizei width,
    706                                                      GLsizei height,
    707                                                      GLenum format,
    708                                                      GLsizei imageSize,
    709                                                      const void *data);
    710 angle::CallCapture CaptureCompressedTextureSubImage3D(const State &glState,
    711                                                      bool isCallValid,
    712                                                      TextureID texturePacked,
    713                                                      GLint level,
    714                                                      GLint xoffset,
    715                                                      GLint yoffset,
    716                                                      GLint zoffset,
    717                                                      GLsizei width,
    718                                                      GLsizei height,
    719                                                      GLsizei depth,
    720                                                      GLenum format,
    721                                                      GLsizei imageSize,
    722                                                      const void *data);
    723 angle::CallCapture CaptureCopyNamedBufferSubData(const State &glState,
    724                                                 bool isCallValid,
    725                                                 GLuint readBuffer,
    726                                                 GLuint writeBuffer,
    727                                                 GLintptr readOffset,
    728                                                 GLintptr writeOffset,
    729                                                 GLsizeiptr size);
    730 angle::CallCapture CaptureCopyTextureSubImage1D(const State &glState,
    731                                                bool isCallValid,
    732                                                TextureID texturePacked,
    733                                                GLint level,
    734                                                GLint xoffset,
    735                                                GLint x,
    736                                                GLint y,
    737                                                GLsizei width);
    738 angle::CallCapture CaptureCopyTextureSubImage2D(const State &glState,
    739                                                bool isCallValid,
    740                                                TextureID texturePacked,
    741                                                GLint level,
    742                                                GLint xoffset,
    743                                                GLint yoffset,
    744                                                GLint x,
    745                                                GLint y,
    746                                                GLsizei width,
    747                                                GLsizei height);
    748 angle::CallCapture CaptureCopyTextureSubImage3D(const State &glState,
    749                                                bool isCallValid,
    750                                                TextureID texturePacked,
    751                                                GLint level,
    752                                                GLint xoffset,
    753                                                GLint yoffset,
    754                                                GLint zoffset,
    755                                                GLint x,
    756                                                GLint y,
    757                                                GLsizei width,
    758                                                GLsizei height);
    759 angle::CallCapture CaptureCreateBuffers(const State &glState,
    760                                        bool isCallValid,
    761                                        GLsizei n,
    762                                        BufferID *buffersPacked);
    763 angle::CallCapture CaptureCreateFramebuffers(const State &glState,
    764                                             bool isCallValid,
    765                                             GLsizei n,
    766                                             GLuint *framebuffers);
    767 angle::CallCapture CaptureCreateProgramPipelines(const State &glState,
    768                                                 bool isCallValid,
    769                                                 GLsizei n,
    770                                                 GLuint *pipelines);
    771 angle::CallCapture CaptureCreateQueries(const State &glState,
    772                                        bool isCallValid,
    773                                        GLenum target,
    774                                        GLsizei n,
    775                                        GLuint *ids);
    776 angle::CallCapture CaptureCreateRenderbuffers(const State &glState,
    777                                              bool isCallValid,
    778                                              GLsizei n,
    779                                              RenderbufferID *renderbuffersPacked);
    780 angle::CallCapture CaptureCreateSamplers(const State &glState,
    781                                         bool isCallValid,
    782                                         GLsizei n,
    783                                         GLuint *samplers);
    784 angle::CallCapture CaptureCreateTextures(const State &glState,
    785                                         bool isCallValid,
    786                                         GLenum target,
    787                                         GLsizei n,
    788                                         GLuint *textures);
    789 angle::CallCapture CaptureCreateTransformFeedbacks(const State &glState,
    790                                                   bool isCallValid,
    791                                                   GLsizei n,
    792                                                   GLuint *ids);
    793 angle::CallCapture CaptureCreateVertexArrays(const State &glState,
    794                                             bool isCallValid,
    795                                             GLsizei n,
    796                                             VertexArrayID *arraysPacked);
    797 angle::CallCapture CaptureDisableVertexArrayAttrib(const State &glState,
    798                                                   bool isCallValid,
    799                                                   VertexArrayID vaobjPacked,
    800                                                   GLuint index);
    801 angle::CallCapture CaptureEnableVertexArrayAttrib(const State &glState,
    802                                                  bool isCallValid,
    803                                                  VertexArrayID vaobjPacked,
    804                                                  GLuint index);
    805 angle::CallCapture CaptureFlushMappedNamedBufferRange(const State &glState,
    806                                                      bool isCallValid,
    807                                                      BufferID bufferPacked,
    808                                                      GLintptr offset,
    809                                                      GLsizeiptr length);
    810 angle::CallCapture CaptureGenerateTextureMipmap(const State &glState,
    811                                                bool isCallValid,
    812                                                TextureID texturePacked);
    813 angle::CallCapture CaptureGetCompressedTextureImage(const State &glState,
    814                                                    bool isCallValid,
    815                                                    TextureID texturePacked,
    816                                                    GLint level,
    817                                                    GLsizei bufSize,
    818                                                    void *pixels);
    819 angle::CallCapture CaptureGetCompressedTextureSubImage(const State &glState,
    820                                                       bool isCallValid,
    821                                                       TextureID texturePacked,
    822                                                       GLint level,
    823                                                       GLint xoffset,
    824                                                       GLint yoffset,
    825                                                       GLint zoffset,
    826                                                       GLsizei width,
    827                                                       GLsizei height,
    828                                                       GLsizei depth,
    829                                                       GLsizei bufSize,
    830                                                       void *pixels);
    831 angle::CallCapture CaptureGetNamedBufferParameteri64v(const State &glState,
    832                                                      bool isCallValid,
    833                                                      BufferID bufferPacked,
    834                                                      GLenum pname,
    835                                                      GLint64 *params);
    836 angle::CallCapture CaptureGetNamedBufferParameteriv(const State &glState,
    837                                                    bool isCallValid,
    838                                                    BufferID bufferPacked,
    839                                                    GLenum pname,
    840                                                    GLint *params);
    841 angle::CallCapture CaptureGetNamedBufferPointerv(const State &glState,
    842                                                 bool isCallValid,
    843                                                 BufferID bufferPacked,
    844                                                 GLenum pname,
    845                                                 void **params);
    846 angle::CallCapture CaptureGetNamedBufferSubData(const State &glState,
    847                                                bool isCallValid,
    848                                                BufferID bufferPacked,
    849                                                GLintptr offset,
    850                                                GLsizeiptr size,
    851                                                void *data);
    852 angle::CallCapture CaptureGetNamedFramebufferAttachmentParameteriv(const State &glState,
    853                                                                   bool isCallValid,
    854                                                                   FramebufferID framebufferPacked,
    855                                                                   GLenum attachment,
    856                                                                   GLenum pname,
    857                                                                   GLint *params);
    858 angle::CallCapture CaptureGetNamedFramebufferParameteriv(const State &glState,
    859                                                         bool isCallValid,
    860                                                         FramebufferID framebufferPacked,
    861                                                         GLenum pname,
    862                                                         GLint *param);
    863 angle::CallCapture CaptureGetNamedRenderbufferParameteriv(const State &glState,
    864                                                          bool isCallValid,
    865                                                          RenderbufferID renderbufferPacked,
    866                                                          GLenum pname,
    867                                                          GLint *params);
    868 angle::CallCapture CaptureGetQueryBufferObjecti64v(const State &glState,
    869                                                   bool isCallValid,
    870                                                   GLuint id,
    871                                                   BufferID bufferPacked,
    872                                                   GLenum pname,
    873                                                   GLintptr offset);
    874 angle::CallCapture CaptureGetQueryBufferObjectiv(const State &glState,
    875                                                 bool isCallValid,
    876                                                 GLuint id,
    877                                                 BufferID bufferPacked,
    878                                                 GLenum pname,
    879                                                 GLintptr offset);
    880 angle::CallCapture CaptureGetQueryBufferObjectui64v(const State &glState,
    881                                                    bool isCallValid,
    882                                                    GLuint id,
    883                                                    BufferID bufferPacked,
    884                                                    GLenum pname,
    885                                                    GLintptr offset);
    886 angle::CallCapture CaptureGetQueryBufferObjectuiv(const State &glState,
    887                                                  bool isCallValid,
    888                                                  GLuint id,
    889                                                  BufferID bufferPacked,
    890                                                  GLenum pname,
    891                                                  GLintptr offset);
    892 angle::CallCapture CaptureGetTextureImage(const State &glState,
    893                                          bool isCallValid,
    894                                          TextureID texturePacked,
    895                                          GLint level,
    896                                          GLenum format,
    897                                          GLenum type,
    898                                          GLsizei bufSize,
    899                                          void *pixels);
    900 angle::CallCapture CaptureGetTextureLevelParameterfv(const State &glState,
    901                                                     bool isCallValid,
    902                                                     TextureID texturePacked,
    903                                                     GLint level,
    904                                                     GLenum pname,
    905                                                     GLfloat *params);
    906 angle::CallCapture CaptureGetTextureLevelParameteriv(const State &glState,
    907                                                     bool isCallValid,
    908                                                     TextureID texturePacked,
    909                                                     GLint level,
    910                                                     GLenum pname,
    911                                                     GLint *params);
    912 angle::CallCapture CaptureGetTextureParameterIiv(const State &glState,
    913                                                 bool isCallValid,
    914                                                 TextureID texturePacked,
    915                                                 GLenum pname,
    916                                                 GLint *params);
    917 angle::CallCapture CaptureGetTextureParameterIuiv(const State &glState,
    918                                                  bool isCallValid,
    919                                                  TextureID texturePacked,
    920                                                  GLenum pname,
    921                                                  GLuint *params);
    922 angle::CallCapture CaptureGetTextureParameterfv(const State &glState,
    923                                                bool isCallValid,
    924                                                TextureID texturePacked,
    925                                                GLenum pname,
    926                                                GLfloat *params);
    927 angle::CallCapture CaptureGetTextureParameteriv(const State &glState,
    928                                                bool isCallValid,
    929                                                TextureID texturePacked,
    930                                                GLenum pname,
    931                                                GLint *params);
    932 angle::CallCapture CaptureGetTextureSubImage(const State &glState,
    933                                             bool isCallValid,
    934                                             TextureID texturePacked,
    935                                             GLint level,
    936                                             GLint xoffset,
    937                                             GLint yoffset,
    938                                             GLint zoffset,
    939                                             GLsizei width,
    940                                             GLsizei height,
    941                                             GLsizei depth,
    942                                             GLenum format,
    943                                             GLenum type,
    944                                             GLsizei bufSize,
    945                                             void *pixels);
    946 angle::CallCapture CaptureGetTransformFeedbacki64_v(const State &glState,
    947                                                    bool isCallValid,
    948                                                    GLuint xfb,
    949                                                    GLenum pname,
    950                                                    GLuint index,
    951                                                    GLint64 *param);
    952 angle::CallCapture CaptureGetTransformFeedbacki_v(const State &glState,
    953                                                  bool isCallValid,
    954                                                  GLuint xfb,
    955                                                  GLenum pname,
    956                                                  GLuint index,
    957                                                  GLint *param);
    958 angle::CallCapture CaptureGetTransformFeedbackiv(const State &glState,
    959                                                 bool isCallValid,
    960                                                 GLuint xfb,
    961                                                 GLenum pname,
    962                                                 GLint *param);
    963 angle::CallCapture CaptureGetVertexArrayIndexed64iv(const State &glState,
    964                                                    bool isCallValid,
    965                                                    VertexArrayID vaobjPacked,
    966                                                    GLuint index,
    967                                                    GLenum pname,
    968                                                    GLint64 *param);
    969 angle::CallCapture CaptureGetVertexArrayIndexediv(const State &glState,
    970                                                  bool isCallValid,
    971                                                  VertexArrayID vaobjPacked,
    972                                                  GLuint index,
    973                                                  GLenum pname,
    974                                                  GLint *param);
    975 angle::CallCapture CaptureGetVertexArrayiv(const State &glState,
    976                                           bool isCallValid,
    977                                           VertexArrayID vaobjPacked,
    978                                           GLenum pname,
    979                                           GLint *param);
    980 angle::CallCapture CaptureGetnColorTable(const State &glState,
    981                                         bool isCallValid,
    982                                         GLenum target,
    983                                         GLenum format,
    984                                         GLenum type,
    985                                         GLsizei bufSize,
    986                                         void *table);
    987 angle::CallCapture CaptureGetnCompressedTexImage(const State &glState,
    988                                                 bool isCallValid,
    989                                                 GLenum target,
    990                                                 GLint lod,
    991                                                 GLsizei bufSize,
    992                                                 void *pixels);
    993 angle::CallCapture CaptureGetnConvolutionFilter(const State &glState,
    994                                                bool isCallValid,
    995                                                GLenum target,
    996                                                GLenum format,
    997                                                GLenum type,
    998                                                GLsizei bufSize,
    999                                                void *image);
   1000 angle::CallCapture CaptureGetnHistogram(const State &glState,
   1001                                        bool isCallValid,
   1002                                        GLenum target,
   1003                                        GLboolean reset,
   1004                                        GLenum format,
   1005                                        GLenum type,
   1006                                        GLsizei bufSize,
   1007                                        void *values);
   1008 angle::CallCapture CaptureGetnMapdv(const State &glState,
   1009                                    bool isCallValid,
   1010                                    GLenum target,
   1011                                    GLenum query,
   1012                                    GLsizei bufSize,
   1013                                    GLdouble *v);
   1014 angle::CallCapture CaptureGetnMapfv(const State &glState,
   1015                                    bool isCallValid,
   1016                                    GLenum target,
   1017                                    GLenum query,
   1018                                    GLsizei bufSize,
   1019                                    GLfloat *v);
   1020 angle::CallCapture CaptureGetnMapiv(const State &glState,
   1021                                    bool isCallValid,
   1022                                    GLenum target,
   1023                                    GLenum query,
   1024                                    GLsizei bufSize,
   1025                                    GLint *v);
   1026 angle::CallCapture CaptureGetnMinmax(const State &glState,
   1027                                     bool isCallValid,
   1028                                     GLenum target,
   1029                                     GLboolean reset,
   1030                                     GLenum format,
   1031                                     GLenum type,
   1032                                     GLsizei bufSize,
   1033                                     void *values);
   1034 angle::CallCapture CaptureGetnPixelMapfv(const State &glState,
   1035                                         bool isCallValid,
   1036                                         GLenum map,
   1037                                         GLsizei bufSize,
   1038                                         GLfloat *values);
   1039 angle::CallCapture CaptureGetnPixelMapuiv(const State &glState,
   1040                                          bool isCallValid,
   1041                                          GLenum map,
   1042                                          GLsizei bufSize,
   1043                                          GLuint *values);
   1044 angle::CallCapture CaptureGetnPixelMapusv(const State &glState,
   1045                                          bool isCallValid,
   1046                                          GLenum map,
   1047                                          GLsizei bufSize,
   1048                                          GLushort *values);
   1049 angle::CallCapture CaptureGetnPolygonStipple(const State &glState,
   1050                                             bool isCallValid,
   1051                                             GLsizei bufSize,
   1052                                             GLubyte *pattern);
   1053 angle::CallCapture CaptureGetnSeparableFilter(const State &glState,
   1054                                              bool isCallValid,
   1055                                              GLenum target,
   1056                                              GLenum format,
   1057                                              GLenum type,
   1058                                              GLsizei rowBufSize,
   1059                                              void *row,
   1060                                              GLsizei columnBufSize,
   1061                                              void *column,
   1062                                              void *span);
   1063 angle::CallCapture CaptureGetnTexImage(const State &glState,
   1064                                       bool isCallValid,
   1065                                       GLenum target,
   1066                                       GLint level,
   1067                                       GLenum format,
   1068                                       GLenum type,
   1069                                       GLsizei bufSize,
   1070                                       void *pixels);
   1071 angle::CallCapture CaptureGetnUniformdv(const State &glState,
   1072                                        bool isCallValid,
   1073                                        ShaderProgramID programPacked,
   1074                                        UniformLocation locationPacked,
   1075                                        GLsizei bufSize,
   1076                                        GLdouble *params);
   1077 angle::CallCapture CaptureInvalidateNamedFramebufferData(const State &glState,
   1078                                                         bool isCallValid,
   1079                                                         FramebufferID framebufferPacked,
   1080                                                         GLsizei numAttachments,
   1081                                                         const GLenum *attachments);
   1082 angle::CallCapture CaptureInvalidateNamedFramebufferSubData(const State &glState,
   1083                                                            bool isCallValid,
   1084                                                            FramebufferID framebufferPacked,
   1085                                                            GLsizei numAttachments,
   1086                                                            const GLenum *attachments,
   1087                                                            GLint x,
   1088                                                            GLint y,
   1089                                                            GLsizei width,
   1090                                                            GLsizei height);
   1091 angle::CallCapture CaptureMapNamedBuffer(const State &glState,
   1092                                         bool isCallValid,
   1093                                         BufferID bufferPacked,
   1094                                         GLenum access,
   1095                                         void *returnValue);
   1096 angle::CallCapture CaptureMapNamedBufferRange(const State &glState,
   1097                                              bool isCallValid,
   1098                                              BufferID bufferPacked,
   1099                                              GLintptr offset,
   1100                                              GLsizeiptr length,
   1101                                              GLbitfield access,
   1102                                              void *returnValue);
   1103 angle::CallCapture CaptureNamedBufferData(const State &glState,
   1104                                          bool isCallValid,
   1105                                          BufferID bufferPacked,
   1106                                          GLsizeiptr size,
   1107                                          const void *data,
   1108                                          GLenum usage);
   1109 angle::CallCapture CaptureNamedBufferStorage(const State &glState,
   1110                                             bool isCallValid,
   1111                                             BufferID bufferPacked,
   1112                                             GLsizeiptr size,
   1113                                             const void *data,
   1114                                             GLbitfield flags);
   1115 angle::CallCapture CaptureNamedBufferSubData(const State &glState,
   1116                                             bool isCallValid,
   1117                                             BufferID bufferPacked,
   1118                                             GLintptr offset,
   1119                                             GLsizeiptr size,
   1120                                             const void *data);
   1121 angle::CallCapture CaptureNamedFramebufferDrawBuffer(const State &glState,
   1122                                                     bool isCallValid,
   1123                                                     FramebufferID framebufferPacked,
   1124                                                     GLenum buf);
   1125 angle::CallCapture CaptureNamedFramebufferDrawBuffers(const State &glState,
   1126                                                      bool isCallValid,
   1127                                                      FramebufferID framebufferPacked,
   1128                                                      GLsizei n,
   1129                                                      const GLenum *bufs);
   1130 angle::CallCapture CaptureNamedFramebufferParameteri(const State &glState,
   1131                                                     bool isCallValid,
   1132                                                     FramebufferID framebufferPacked,
   1133                                                     GLenum pname,
   1134                                                     GLint param);
   1135 angle::CallCapture CaptureNamedFramebufferReadBuffer(const State &glState,
   1136                                                     bool isCallValid,
   1137                                                     FramebufferID framebufferPacked,
   1138                                                     GLenum src);
   1139 angle::CallCapture CaptureNamedFramebufferRenderbuffer(const State &glState,
   1140                                                       bool isCallValid,
   1141                                                       FramebufferID framebufferPacked,
   1142                                                       GLenum attachment,
   1143                                                       GLenum renderbuffertarget,
   1144                                                       RenderbufferID renderbufferPacked);
   1145 angle::CallCapture CaptureNamedFramebufferTexture(const State &glState,
   1146                                                  bool isCallValid,
   1147                                                  FramebufferID framebufferPacked,
   1148                                                  GLenum attachment,
   1149                                                  TextureID texturePacked,
   1150                                                  GLint level);
   1151 angle::CallCapture CaptureNamedFramebufferTextureLayer(const State &glState,
   1152                                                       bool isCallValid,
   1153                                                       FramebufferID framebufferPacked,
   1154                                                       GLenum attachment,
   1155                                                       TextureID texturePacked,
   1156                                                       GLint level,
   1157                                                       GLint layer);
   1158 angle::CallCapture CaptureNamedRenderbufferStorage(const State &glState,
   1159                                                   bool isCallValid,
   1160                                                   RenderbufferID renderbufferPacked,
   1161                                                   GLenum internalformat,
   1162                                                   GLsizei width,
   1163                                                   GLsizei height);
   1164 angle::CallCapture CaptureNamedRenderbufferStorageMultisample(const State &glState,
   1165                                                              bool isCallValid,
   1166                                                              RenderbufferID renderbufferPacked,
   1167                                                              GLsizei samples,
   1168                                                              GLenum internalformat,
   1169                                                              GLsizei width,
   1170                                                              GLsizei height);
   1171 angle::CallCapture CaptureTextureBarrier(const State &glState, bool isCallValid);
   1172 angle::CallCapture CaptureTextureBuffer(const State &glState,
   1173                                        bool isCallValid,
   1174                                        TextureID texturePacked,
   1175                                        GLenum internalformat,
   1176                                        BufferID bufferPacked);
   1177 angle::CallCapture CaptureTextureBufferRange(const State &glState,
   1178                                             bool isCallValid,
   1179                                             TextureID texturePacked,
   1180                                             GLenum internalformat,
   1181                                             BufferID bufferPacked,
   1182                                             GLintptr offset,
   1183                                             GLsizeiptr size);
   1184 angle::CallCapture CaptureTextureParameterIiv(const State &glState,
   1185                                              bool isCallValid,
   1186                                              TextureID texturePacked,
   1187                                              GLenum pname,
   1188                                              const GLint *params);
   1189 angle::CallCapture CaptureTextureParameterIuiv(const State &glState,
   1190                                               bool isCallValid,
   1191                                               TextureID texturePacked,
   1192                                               GLenum pname,
   1193                                               const GLuint *params);
   1194 angle::CallCapture CaptureTextureParameterf(const State &glState,
   1195                                            bool isCallValid,
   1196                                            TextureID texturePacked,
   1197                                            GLenum pname,
   1198                                            GLfloat param);
   1199 angle::CallCapture CaptureTextureParameterfv(const State &glState,
   1200                                             bool isCallValid,
   1201                                             TextureID texturePacked,
   1202                                             GLenum pname,
   1203                                             const GLfloat *param);
   1204 angle::CallCapture CaptureTextureParameteri(const State &glState,
   1205                                            bool isCallValid,
   1206                                            TextureID texturePacked,
   1207                                            GLenum pname,
   1208                                            GLint param);
   1209 angle::CallCapture CaptureTextureParameteriv(const State &glState,
   1210                                             bool isCallValid,
   1211                                             TextureID texturePacked,
   1212                                             GLenum pname,
   1213                                             const GLint *param);
   1214 angle::CallCapture CaptureTextureStorage1D(const State &glState,
   1215                                           bool isCallValid,
   1216                                           TextureID texturePacked,
   1217                                           GLsizei levels,
   1218                                           GLenum internalformat,
   1219                                           GLsizei width);
   1220 angle::CallCapture CaptureTextureStorage2D(const State &glState,
   1221                                           bool isCallValid,
   1222                                           TextureID texturePacked,
   1223                                           GLsizei levels,
   1224                                           GLenum internalformat,
   1225                                           GLsizei width,
   1226                                           GLsizei height);
   1227 angle::CallCapture CaptureTextureStorage2DMultisample(const State &glState,
   1228                                                      bool isCallValid,
   1229                                                      TextureID texturePacked,
   1230                                                      GLsizei samples,
   1231                                                      GLenum internalformat,
   1232                                                      GLsizei width,
   1233                                                      GLsizei height,
   1234                                                      GLboolean fixedsamplelocations);
   1235 angle::CallCapture CaptureTextureStorage3D(const State &glState,
   1236                                           bool isCallValid,
   1237                                           TextureID texturePacked,
   1238                                           GLsizei levels,
   1239                                           GLenum internalformat,
   1240                                           GLsizei width,
   1241                                           GLsizei height,
   1242                                           GLsizei depth);
   1243 angle::CallCapture CaptureTextureStorage3DMultisample(const State &glState,
   1244                                                      bool isCallValid,
   1245                                                      TextureID texturePacked,
   1246                                                      GLsizei samples,
   1247                                                      GLenum internalformat,
   1248                                                      GLsizei width,
   1249                                                      GLsizei height,
   1250                                                      GLsizei depth,
   1251                                                      GLboolean fixedsamplelocations);
   1252 angle::CallCapture CaptureTextureSubImage1D(const State &glState,
   1253                                            bool isCallValid,
   1254                                            TextureID texturePacked,
   1255                                            GLint level,
   1256                                            GLint xoffset,
   1257                                            GLsizei width,
   1258                                            GLenum format,
   1259                                            GLenum type,
   1260                                            const void *pixels);
   1261 angle::CallCapture CaptureTextureSubImage2D(const State &glState,
   1262                                            bool isCallValid,
   1263                                            TextureID texturePacked,
   1264                                            GLint level,
   1265                                            GLint xoffset,
   1266                                            GLint yoffset,
   1267                                            GLsizei width,
   1268                                            GLsizei height,
   1269                                            GLenum format,
   1270                                            GLenum type,
   1271                                            const void *pixels);
   1272 angle::CallCapture CaptureTextureSubImage3D(const State &glState,
   1273                                            bool isCallValid,
   1274                                            TextureID texturePacked,
   1275                                            GLint level,
   1276                                            GLint xoffset,
   1277                                            GLint yoffset,
   1278                                            GLint zoffset,
   1279                                            GLsizei width,
   1280                                            GLsizei height,
   1281                                            GLsizei depth,
   1282                                            GLenum format,
   1283                                            GLenum type,
   1284                                            const void *pixels);
   1285 angle::CallCapture CaptureTransformFeedbackBufferBase(const State &glState,
   1286                                                      bool isCallValid,
   1287                                                      GLuint xfb,
   1288                                                      GLuint index,
   1289                                                      BufferID bufferPacked);
   1290 angle::CallCapture CaptureTransformFeedbackBufferRange(const State &glState,
   1291                                                       bool isCallValid,
   1292                                                       GLuint xfb,
   1293                                                       GLuint index,
   1294                                                       BufferID bufferPacked,
   1295                                                       GLintptr offset,
   1296                                                       GLsizeiptr size);
   1297 angle::CallCapture CaptureUnmapNamedBuffer(const State &glState,
   1298                                           bool isCallValid,
   1299                                           BufferID bufferPacked,
   1300                                           GLboolean returnValue);
   1301 angle::CallCapture CaptureVertexArrayAttribBinding(const State &glState,
   1302                                                   bool isCallValid,
   1303                                                   VertexArrayID vaobjPacked,
   1304                                                   GLuint attribindex,
   1305                                                   GLuint bindingindex);
   1306 angle::CallCapture CaptureVertexArrayAttribFormat(const State &glState,
   1307                                                  bool isCallValid,
   1308                                                  VertexArrayID vaobjPacked,
   1309                                                  GLuint attribindex,
   1310                                                  GLint size,
   1311                                                  GLenum type,
   1312                                                  GLboolean normalized,
   1313                                                  GLuint relativeoffset);
   1314 angle::CallCapture CaptureVertexArrayAttribIFormat(const State &glState,
   1315                                                   bool isCallValid,
   1316                                                   VertexArrayID vaobjPacked,
   1317                                                   GLuint attribindex,
   1318                                                   GLint size,
   1319                                                   GLenum type,
   1320                                                   GLuint relativeoffset);
   1321 angle::CallCapture CaptureVertexArrayAttribLFormat(const State &glState,
   1322                                                   bool isCallValid,
   1323                                                   VertexArrayID vaobjPacked,
   1324                                                   GLuint attribindex,
   1325                                                   GLint size,
   1326                                                   GLenum type,
   1327                                                   GLuint relativeoffset);
   1328 angle::CallCapture CaptureVertexArrayBindingDivisor(const State &glState,
   1329                                                    bool isCallValid,
   1330                                                    VertexArrayID vaobjPacked,
   1331                                                    GLuint bindingindex,
   1332                                                    GLuint divisor);
   1333 angle::CallCapture CaptureVertexArrayElementBuffer(const State &glState,
   1334                                                   bool isCallValid,
   1335                                                   VertexArrayID vaobjPacked,
   1336                                                   BufferID bufferPacked);
   1337 angle::CallCapture CaptureVertexArrayVertexBuffer(const State &glState,
   1338                                                  bool isCallValid,
   1339                                                  VertexArrayID vaobjPacked,
   1340                                                  GLuint bindingindex,
   1341                                                  BufferID bufferPacked,
   1342                                                  GLintptr offset,
   1343                                                  GLsizei stride);
   1344 angle::CallCapture CaptureVertexArrayVertexBuffers(const State &glState,
   1345                                                   bool isCallValid,
   1346                                                   VertexArrayID vaobjPacked,
   1347                                                   GLuint first,
   1348                                                   GLsizei count,
   1349                                                   const BufferID *buffersPacked,
   1350                                                   const GLintptr *offsets,
   1351                                                   const GLsizei *strides);
   1352 
   1353 // GL 4.6
   1354 angle::CallCapture CaptureMultiDrawArraysIndirectCount(const State &glState,
   1355                                                       bool isCallValid,
   1356                                                       GLenum mode,
   1357                                                       const void *indirect,
   1358                                                       GLintptr drawcount,
   1359                                                       GLsizei maxdrawcount,
   1360                                                       GLsizei stride);
   1361 angle::CallCapture CaptureMultiDrawElementsIndirectCount(const State &glState,
   1362                                                         bool isCallValid,
   1363                                                         GLenum mode,
   1364                                                         GLenum type,
   1365                                                         const void *indirect,
   1366                                                         GLintptr drawcount,
   1367                                                         GLsizei maxdrawcount,
   1368                                                         GLsizei stride);
   1369 angle::CallCapture CapturePolygonOffsetClamp(const State &glState,
   1370                                             bool isCallValid,
   1371                                             GLfloat factor,
   1372                                             GLfloat units,
   1373                                             GLfloat clamp);
   1374 angle::CallCapture CaptureSpecializeShader(const State &glState,
   1375                                           bool isCallValid,
   1376                                           GLuint shader,
   1377                                           const GLchar *pEntryPoint,
   1378                                           GLuint numSpecializationConstants,
   1379                                           const GLuint *pConstantIndex,
   1380                                           const GLuint *pConstantValue);
   1381 
   1382 // Parameter Captures
   1383 
   1384 // GL 4.0
   1385 void CaptureGetActiveSubroutineName_length(const State &glState,
   1386                                           bool isCallValid,
   1387                                           ShaderProgramID programPacked,
   1388                                           GLenum shadertype,
   1389                                           GLuint index,
   1390                                           GLsizei bufSize,
   1391                                           GLsizei *length,
   1392                                           GLchar *name,
   1393                                           angle::ParamCapture *paramCapture);
   1394 void CaptureGetActiveSubroutineName_name(const State &glState,
   1395                                         bool isCallValid,
   1396                                         ShaderProgramID programPacked,
   1397                                         GLenum shadertype,
   1398                                         GLuint index,
   1399                                         GLsizei bufSize,
   1400                                         GLsizei *length,
   1401                                         GLchar *name,
   1402                                         angle::ParamCapture *paramCapture);
   1403 void CaptureGetActiveSubroutineUniformName_length(const State &glState,
   1404                                                  bool isCallValid,
   1405                                                  ShaderProgramID programPacked,
   1406                                                  GLenum shadertype,
   1407                                                  GLuint index,
   1408                                                  GLsizei bufSize,
   1409                                                  GLsizei *length,
   1410                                                  GLchar *name,
   1411                                                  angle::ParamCapture *paramCapture);
   1412 void CaptureGetActiveSubroutineUniformName_name(const State &glState,
   1413                                                bool isCallValid,
   1414                                                ShaderProgramID programPacked,
   1415                                                GLenum shadertype,
   1416                                                GLuint index,
   1417                                                GLsizei bufSize,
   1418                                                GLsizei *length,
   1419                                                GLchar *name,
   1420                                                angle::ParamCapture *paramCapture);
   1421 void CaptureGetActiveSubroutineUniformiv_values(const State &glState,
   1422                                                bool isCallValid,
   1423                                                ShaderProgramID programPacked,
   1424                                                GLenum shadertype,
   1425                                                GLuint index,
   1426                                                GLenum pname,
   1427                                                GLint *values,
   1428                                                angle::ParamCapture *paramCapture);
   1429 void CaptureGetProgramStageiv_values(const State &glState,
   1430                                     bool isCallValid,
   1431                                     ShaderProgramID programPacked,
   1432                                     GLenum shadertype,
   1433                                     GLenum pname,
   1434                                     GLint *values,
   1435                                     angle::ParamCapture *paramCapture);
   1436 void CaptureGetQueryIndexediv_params(const State &glState,
   1437                                     bool isCallValid,
   1438                                     GLenum target,
   1439                                     GLuint index,
   1440                                     GLenum pname,
   1441                                     GLint *params,
   1442                                     angle::ParamCapture *paramCapture);
   1443 void CaptureGetSubroutineIndex_name(const State &glState,
   1444                                    bool isCallValid,
   1445                                    ShaderProgramID programPacked,
   1446                                    GLenum shadertype,
   1447                                    const GLchar *name,
   1448                                    angle::ParamCapture *paramCapture);
   1449 void CaptureGetSubroutineUniformLocation_name(const State &glState,
   1450                                              bool isCallValid,
   1451                                              ShaderProgramID programPacked,
   1452                                              GLenum shadertype,
   1453                                              const GLchar *name,
   1454                                              angle::ParamCapture *paramCapture);
   1455 void CaptureGetUniformSubroutineuiv_params(const State &glState,
   1456                                           bool isCallValid,
   1457                                           GLenum shadertype,
   1458                                           GLint location,
   1459                                           GLuint *params,
   1460                                           angle::ParamCapture *paramCapture);
   1461 void CaptureGetUniformdv_params(const State &glState,
   1462                                bool isCallValid,
   1463                                ShaderProgramID programPacked,
   1464                                UniformLocation locationPacked,
   1465                                GLdouble *params,
   1466                                angle::ParamCapture *paramCapture);
   1467 void CapturePatchParameterfv_values(const State &glState,
   1468                                    bool isCallValid,
   1469                                    GLenum pname,
   1470                                    const GLfloat *values,
   1471                                    angle::ParamCapture *paramCapture);
   1472 void CaptureUniform1dv_value(const State &glState,
   1473                             bool isCallValid,
   1474                             UniformLocation locationPacked,
   1475                             GLsizei count,
   1476                             const GLdouble *value,
   1477                             angle::ParamCapture *paramCapture);
   1478 void CaptureUniform2dv_value(const State &glState,
   1479                             bool isCallValid,
   1480                             UniformLocation locationPacked,
   1481                             GLsizei count,
   1482                             const GLdouble *value,
   1483                             angle::ParamCapture *paramCapture);
   1484 void CaptureUniform3dv_value(const State &glState,
   1485                             bool isCallValid,
   1486                             UniformLocation locationPacked,
   1487                             GLsizei count,
   1488                             const GLdouble *value,
   1489                             angle::ParamCapture *paramCapture);
   1490 void CaptureUniform4dv_value(const State &glState,
   1491                             bool isCallValid,
   1492                             UniformLocation locationPacked,
   1493                             GLsizei count,
   1494                             const GLdouble *value,
   1495                             angle::ParamCapture *paramCapture);
   1496 void CaptureUniformMatrix2dv_value(const State &glState,
   1497                                   bool isCallValid,
   1498                                   UniformLocation locationPacked,
   1499                                   GLsizei count,
   1500                                   GLboolean transpose,
   1501                                   const GLdouble *value,
   1502                                   angle::ParamCapture *paramCapture);
   1503 void CaptureUniformMatrix2x3dv_value(const State &glState,
   1504                                     bool isCallValid,
   1505                                     UniformLocation locationPacked,
   1506                                     GLsizei count,
   1507                                     GLboolean transpose,
   1508                                     const GLdouble *value,
   1509                                     angle::ParamCapture *paramCapture);
   1510 void CaptureUniformMatrix2x4dv_value(const State &glState,
   1511                                     bool isCallValid,
   1512                                     UniformLocation locationPacked,
   1513                                     GLsizei count,
   1514                                     GLboolean transpose,
   1515                                     const GLdouble *value,
   1516                                     angle::ParamCapture *paramCapture);
   1517 void CaptureUniformMatrix3dv_value(const State &glState,
   1518                                   bool isCallValid,
   1519                                   UniformLocation locationPacked,
   1520                                   GLsizei count,
   1521                                   GLboolean transpose,
   1522                                   const GLdouble *value,
   1523                                   angle::ParamCapture *paramCapture);
   1524 void CaptureUniformMatrix3x2dv_value(const State &glState,
   1525                                     bool isCallValid,
   1526                                     UniformLocation locationPacked,
   1527                                     GLsizei count,
   1528                                     GLboolean transpose,
   1529                                     const GLdouble *value,
   1530                                     angle::ParamCapture *paramCapture);
   1531 void CaptureUniformMatrix3x4dv_value(const State &glState,
   1532                                     bool isCallValid,
   1533                                     UniformLocation locationPacked,
   1534                                     GLsizei count,
   1535                                     GLboolean transpose,
   1536                                     const GLdouble *value,
   1537                                     angle::ParamCapture *paramCapture);
   1538 void CaptureUniformMatrix4dv_value(const State &glState,
   1539                                   bool isCallValid,
   1540                                   UniformLocation locationPacked,
   1541                                   GLsizei count,
   1542                                   GLboolean transpose,
   1543                                   const GLdouble *value,
   1544                                   angle::ParamCapture *paramCapture);
   1545 void CaptureUniformMatrix4x2dv_value(const State &glState,
   1546                                     bool isCallValid,
   1547                                     UniformLocation locationPacked,
   1548                                     GLsizei count,
   1549                                     GLboolean transpose,
   1550                                     const GLdouble *value,
   1551                                     angle::ParamCapture *paramCapture);
   1552 void CaptureUniformMatrix4x3dv_value(const State &glState,
   1553                                     bool isCallValid,
   1554                                     UniformLocation locationPacked,
   1555                                     GLsizei count,
   1556                                     GLboolean transpose,
   1557                                     const GLdouble *value,
   1558                                     angle::ParamCapture *paramCapture);
   1559 void CaptureUniformSubroutinesuiv_indices(const State &glState,
   1560                                          bool isCallValid,
   1561                                          GLenum shadertype,
   1562                                          GLsizei count,
   1563                                          const GLuint *indices,
   1564                                          angle::ParamCapture *paramCapture);
   1565 
   1566 // GL 4.1
   1567 void CaptureDepthRangeArrayv_v(const State &glState,
   1568                               bool isCallValid,
   1569                               GLuint first,
   1570                               GLsizei count,
   1571                               const GLdouble *v,
   1572                               angle::ParamCapture *paramCapture);
   1573 void CaptureGetDoublei_v_data(const State &glState,
   1574                              bool isCallValid,
   1575                              GLenum target,
   1576                              GLuint index,
   1577                              GLdouble *data,
   1578                              angle::ParamCapture *paramCapture);
   1579 void CaptureGetFloati_v_data(const State &glState,
   1580                             bool isCallValid,
   1581                             GLenum target,
   1582                             GLuint index,
   1583                             GLfloat *data,
   1584                             angle::ParamCapture *paramCapture);
   1585 void CaptureGetVertexAttribLdv_params(const State &glState,
   1586                                      bool isCallValid,
   1587                                      GLuint index,
   1588                                      GLenum pname,
   1589                                      GLdouble *params,
   1590                                      angle::ParamCapture *paramCapture);
   1591 void CaptureProgramUniform1dv_value(const State &glState,
   1592                                    bool isCallValid,
   1593                                    ShaderProgramID programPacked,
   1594                                    UniformLocation locationPacked,
   1595                                    GLsizei count,
   1596                                    const GLdouble *value,
   1597                                    angle::ParamCapture *paramCapture);
   1598 void CaptureProgramUniform2dv_value(const State &glState,
   1599                                    bool isCallValid,
   1600                                    ShaderProgramID programPacked,
   1601                                    UniformLocation locationPacked,
   1602                                    GLsizei count,
   1603                                    const GLdouble *value,
   1604                                    angle::ParamCapture *paramCapture);
   1605 void CaptureProgramUniform3dv_value(const State &glState,
   1606                                    bool isCallValid,
   1607                                    ShaderProgramID programPacked,
   1608                                    UniformLocation locationPacked,
   1609                                    GLsizei count,
   1610                                    const GLdouble *value,
   1611                                    angle::ParamCapture *paramCapture);
   1612 void CaptureProgramUniform4dv_value(const State &glState,
   1613                                    bool isCallValid,
   1614                                    ShaderProgramID programPacked,
   1615                                    UniformLocation locationPacked,
   1616                                    GLsizei count,
   1617                                    const GLdouble *value,
   1618                                    angle::ParamCapture *paramCapture);
   1619 void CaptureProgramUniformMatrix2dv_value(const State &glState,
   1620                                          bool isCallValid,
   1621                                          ShaderProgramID programPacked,
   1622                                          UniformLocation locationPacked,
   1623                                          GLsizei count,
   1624                                          GLboolean transpose,
   1625                                          const GLdouble *value,
   1626                                          angle::ParamCapture *paramCapture);
   1627 void CaptureProgramUniformMatrix2x3dv_value(const State &glState,
   1628                                            bool isCallValid,
   1629                                            ShaderProgramID programPacked,
   1630                                            UniformLocation locationPacked,
   1631                                            GLsizei count,
   1632                                            GLboolean transpose,
   1633                                            const GLdouble *value,
   1634                                            angle::ParamCapture *paramCapture);
   1635 void CaptureProgramUniformMatrix2x4dv_value(const State &glState,
   1636                                            bool isCallValid,
   1637                                            ShaderProgramID programPacked,
   1638                                            UniformLocation locationPacked,
   1639                                            GLsizei count,
   1640                                            GLboolean transpose,
   1641                                            const GLdouble *value,
   1642                                            angle::ParamCapture *paramCapture);
   1643 void CaptureProgramUniformMatrix3dv_value(const State &glState,
   1644                                          bool isCallValid,
   1645                                          ShaderProgramID programPacked,
   1646                                          UniformLocation locationPacked,
   1647                                          GLsizei count,
   1648                                          GLboolean transpose,
   1649                                          const GLdouble *value,
   1650                                          angle::ParamCapture *paramCapture);
   1651 void CaptureProgramUniformMatrix3x2dv_value(const State &glState,
   1652                                            bool isCallValid,
   1653                                            ShaderProgramID programPacked,
   1654                                            UniformLocation locationPacked,
   1655                                            GLsizei count,
   1656                                            GLboolean transpose,
   1657                                            const GLdouble *value,
   1658                                            angle::ParamCapture *paramCapture);
   1659 void CaptureProgramUniformMatrix3x4dv_value(const State &glState,
   1660                                            bool isCallValid,
   1661                                            ShaderProgramID programPacked,
   1662                                            UniformLocation locationPacked,
   1663                                            GLsizei count,
   1664                                            GLboolean transpose,
   1665                                            const GLdouble *value,
   1666                                            angle::ParamCapture *paramCapture);
   1667 void CaptureProgramUniformMatrix4dv_value(const State &glState,
   1668                                          bool isCallValid,
   1669                                          ShaderProgramID programPacked,
   1670                                          UniformLocation locationPacked,
   1671                                          GLsizei count,
   1672                                          GLboolean transpose,
   1673                                          const GLdouble *value,
   1674                                          angle::ParamCapture *paramCapture);
   1675 void CaptureProgramUniformMatrix4x2dv_value(const State &glState,
   1676                                            bool isCallValid,
   1677                                            ShaderProgramID programPacked,
   1678                                            UniformLocation locationPacked,
   1679                                            GLsizei count,
   1680                                            GLboolean transpose,
   1681                                            const GLdouble *value,
   1682                                            angle::ParamCapture *paramCapture);
   1683 void CaptureProgramUniformMatrix4x3dv_value(const State &glState,
   1684                                            bool isCallValid,
   1685                                            ShaderProgramID programPacked,
   1686                                            UniformLocation locationPacked,
   1687                                            GLsizei count,
   1688                                            GLboolean transpose,
   1689                                            const GLdouble *value,
   1690                                            angle::ParamCapture *paramCapture);
   1691 void CaptureScissorArrayv_v(const State &glState,
   1692                            bool isCallValid,
   1693                            GLuint first,
   1694                            GLsizei count,
   1695                            const GLint *v,
   1696                            angle::ParamCapture *paramCapture);
   1697 void CaptureScissorIndexedv_v(const State &glState,
   1698                              bool isCallValid,
   1699                              GLuint index,
   1700                              const GLint *v,
   1701                              angle::ParamCapture *paramCapture);
   1702 void CaptureVertexAttribL1dv_v(const State &glState,
   1703                               bool isCallValid,
   1704                               GLuint index,
   1705                               const GLdouble *v,
   1706                               angle::ParamCapture *paramCapture);
   1707 void CaptureVertexAttribL2dv_v(const State &glState,
   1708                               bool isCallValid,
   1709                               GLuint index,
   1710                               const GLdouble *v,
   1711                               angle::ParamCapture *paramCapture);
   1712 void CaptureVertexAttribL3dv_v(const State &glState,
   1713                               bool isCallValid,
   1714                               GLuint index,
   1715                               const GLdouble *v,
   1716                               angle::ParamCapture *paramCapture);
   1717 void CaptureVertexAttribL4dv_v(const State &glState,
   1718                               bool isCallValid,
   1719                               GLuint index,
   1720                               const GLdouble *v,
   1721                               angle::ParamCapture *paramCapture);
   1722 void CaptureVertexAttribLPointer_pointer(const State &glState,
   1723                                         bool isCallValid,
   1724                                         GLuint index,
   1725                                         GLint size,
   1726                                         GLenum type,
   1727                                         GLsizei stride,
   1728                                         const void *pointer,
   1729                                         angle::ParamCapture *paramCapture);
   1730 void CaptureViewportArrayv_v(const State &glState,
   1731                             bool isCallValid,
   1732                             GLuint first,
   1733                             GLsizei count,
   1734                             const GLfloat *v,
   1735                             angle::ParamCapture *paramCapture);
   1736 void CaptureViewportIndexedfv_v(const State &glState,
   1737                                bool isCallValid,
   1738                                GLuint index,
   1739                                const GLfloat *v,
   1740                                angle::ParamCapture *paramCapture);
   1741 
   1742 // GL 4.2
   1743 void CaptureDrawElementsInstancedBaseInstance_indices(const State &glState,
   1744                                                      bool isCallValid,
   1745                                                      PrimitiveMode modePacked,
   1746                                                      GLsizei count,
   1747                                                      DrawElementsType typePacked,
   1748                                                      const void *indices,
   1749                                                      GLsizei instancecount,
   1750                                                      GLuint baseinstance,
   1751                                                      angle::ParamCapture *paramCapture);
   1752 void CaptureDrawElementsInstancedBaseVertexBaseInstance_indices(const State &glState,
   1753                                                                bool isCallValid,
   1754                                                                PrimitiveMode modePacked,
   1755                                                                GLsizei count,
   1756                                                                DrawElementsType typePacked,
   1757                                                                const void *indices,
   1758                                                                GLsizei instancecount,
   1759                                                                GLint basevertex,
   1760                                                                GLuint baseinstance,
   1761                                                                angle::ParamCapture *paramCapture);
   1762 void CaptureGetActiveAtomicCounterBufferiv_params(const State &glState,
   1763                                                  bool isCallValid,
   1764                                                  ShaderProgramID programPacked,
   1765                                                  GLuint bufferIndex,
   1766                                                  GLenum pname,
   1767                                                  GLint *params,
   1768                                                  angle::ParamCapture *paramCapture);
   1769 
   1770 // GL 4.3
   1771 void CaptureClearBufferData_data(const State &glState,
   1772                                 bool isCallValid,
   1773                                 GLenum target,
   1774                                 GLenum internalformat,
   1775                                 GLenum format,
   1776                                 GLenum type,
   1777                                 const void *data,
   1778                                 angle::ParamCapture *paramCapture);
   1779 void CaptureClearBufferSubData_data(const State &glState,
   1780                                    bool isCallValid,
   1781                                    GLenum target,
   1782                                    GLenum internalformat,
   1783                                    GLintptr offset,
   1784                                    GLsizeiptr size,
   1785                                    GLenum format,
   1786                                    GLenum type,
   1787                                    const void *data,
   1788                                    angle::ParamCapture *paramCapture);
   1789 void CaptureGetInternalformati64v_params(const State &glState,
   1790                                         bool isCallValid,
   1791                                         GLenum target,
   1792                                         GLenum internalformat,
   1793                                         GLenum pname,
   1794                                         GLsizei count,
   1795                                         GLint64 *params,
   1796                                         angle::ParamCapture *paramCapture);
   1797 void CaptureGetProgramResourceLocationIndex_name(const State &glState,
   1798                                                 bool isCallValid,
   1799                                                 ShaderProgramID programPacked,
   1800                                                 GLenum programInterface,
   1801                                                 const GLchar *name,
   1802                                                 angle::ParamCapture *paramCapture);
   1803 void CaptureMultiDrawArraysIndirect_indirect(const State &glState,
   1804                                             bool isCallValid,
   1805                                             PrimitiveMode modePacked,
   1806                                             const void *indirect,
   1807                                             GLsizei drawcount,
   1808                                             GLsizei stride,
   1809                                             angle::ParamCapture *paramCapture);
   1810 void CaptureMultiDrawElementsIndirect_indirect(const State &glState,
   1811                                               bool isCallValid,
   1812                                               PrimitiveMode modePacked,
   1813                                               DrawElementsType typePacked,
   1814                                               const void *indirect,
   1815                                               GLsizei drawcount,
   1816                                               GLsizei stride,
   1817                                               angle::ParamCapture *paramCapture);
   1818 
   1819 // GL 4.4
   1820 void CaptureBindBuffersBase_buffersPacked(const State &glState,
   1821                                          bool isCallValid,
   1822                                          GLenum target,
   1823                                          GLuint first,
   1824                                          GLsizei count,
   1825                                          const BufferID *buffersPacked,
   1826                                          angle::ParamCapture *paramCapture);
   1827 void CaptureBindBuffersRange_buffersPacked(const State &glState,
   1828                                           bool isCallValid,
   1829                                           GLenum target,
   1830                                           GLuint first,
   1831                                           GLsizei count,
   1832                                           const BufferID *buffersPacked,
   1833                                           const GLintptr *offsets,
   1834                                           const GLsizeiptr *sizes,
   1835                                           angle::ParamCapture *paramCapture);
   1836 void CaptureBindBuffersRange_offsets(const State &glState,
   1837                                     bool isCallValid,
   1838                                     GLenum target,
   1839                                     GLuint first,
   1840                                     GLsizei count,
   1841                                     const BufferID *buffersPacked,
   1842                                     const GLintptr *offsets,
   1843                                     const GLsizeiptr *sizes,
   1844                                     angle::ParamCapture *paramCapture);
   1845 void CaptureBindBuffersRange_sizes(const State &glState,
   1846                                   bool isCallValid,
   1847                                   GLenum target,
   1848                                   GLuint first,
   1849                                   GLsizei count,
   1850                                   const BufferID *buffersPacked,
   1851                                   const GLintptr *offsets,
   1852                                   const GLsizeiptr *sizes,
   1853                                   angle::ParamCapture *paramCapture);
   1854 void CaptureBindImageTextures_textures(const State &glState,
   1855                                       bool isCallValid,
   1856                                       GLuint first,
   1857                                       GLsizei count,
   1858                                       const GLuint *textures,
   1859                                       angle::ParamCapture *paramCapture);
   1860 void CaptureBindSamplers_samplers(const State &glState,
   1861                                  bool isCallValid,
   1862                                  GLuint first,
   1863                                  GLsizei count,
   1864                                  const GLuint *samplers,
   1865                                  angle::ParamCapture *paramCapture);
   1866 void CaptureBindTextures_textures(const State &glState,
   1867                                  bool isCallValid,
   1868                                  GLuint first,
   1869                                  GLsizei count,
   1870                                  const GLuint *textures,
   1871                                  angle::ParamCapture *paramCapture);
   1872 void CaptureBindVertexBuffers_buffersPacked(const State &glState,
   1873                                            bool isCallValid,
   1874                                            GLuint first,
   1875                                            GLsizei count,
   1876                                            const BufferID *buffersPacked,
   1877                                            const GLintptr *offsets,
   1878                                            const GLsizei *strides,
   1879                                            angle::ParamCapture *paramCapture);
   1880 void CaptureBindVertexBuffers_offsets(const State &glState,
   1881                                      bool isCallValid,
   1882                                      GLuint first,
   1883                                      GLsizei count,
   1884                                      const BufferID *buffersPacked,
   1885                                      const GLintptr *offsets,
   1886                                      const GLsizei *strides,
   1887                                      angle::ParamCapture *paramCapture);
   1888 void CaptureBindVertexBuffers_strides(const State &glState,
   1889                                      bool isCallValid,
   1890                                      GLuint first,
   1891                                      GLsizei count,
   1892                                      const BufferID *buffersPacked,
   1893                                      const GLintptr *offsets,
   1894                                      const GLsizei *strides,
   1895                                      angle::ParamCapture *paramCapture);
   1896 void CaptureBufferStorage_data(const State &glState,
   1897                               bool isCallValid,
   1898                               BufferBinding targetPacked,
   1899                               GLsizeiptr size,
   1900                               const void *data,
   1901                               GLbitfield flags,
   1902                               angle::ParamCapture *paramCapture);
   1903 void CaptureClearTexImage_data(const State &glState,
   1904                               bool isCallValid,
   1905                               TextureID texturePacked,
   1906                               GLint level,
   1907                               GLenum format,
   1908                               GLenum type,
   1909                               const void *data,
   1910                               angle::ParamCapture *paramCapture);
   1911 void CaptureClearTexSubImage_data(const State &glState,
   1912                                  bool isCallValid,
   1913                                  TextureID texturePacked,
   1914                                  GLint level,
   1915                                  GLint xoffset,
   1916                                  GLint yoffset,
   1917                                  GLint zoffset,
   1918                                  GLsizei width,
   1919                                  GLsizei height,
   1920                                  GLsizei depth,
   1921                                  GLenum format,
   1922                                  GLenum type,
   1923                                  const void *data,
   1924                                  angle::ParamCapture *paramCapture);
   1925 
   1926 // GL 4.5
   1927 void CaptureClearNamedBufferData_data(const State &glState,
   1928                                      bool isCallValid,
   1929                                      BufferID bufferPacked,
   1930                                      GLenum internalformat,
   1931                                      GLenum format,
   1932                                      GLenum type,
   1933                                      const void *data,
   1934                                      angle::ParamCapture *paramCapture);
   1935 void CaptureClearNamedBufferSubData_data(const State &glState,
   1936                                         bool isCallValid,
   1937                                         BufferID bufferPacked,
   1938                                         GLenum internalformat,
   1939                                         GLintptr offset,
   1940                                         GLsizeiptr size,
   1941                                         GLenum format,
   1942                                         GLenum type,
   1943                                         const void *data,
   1944                                         angle::ParamCapture *paramCapture);
   1945 void CaptureClearNamedFramebufferfv_value(const State &glState,
   1946                                          bool isCallValid,
   1947                                          FramebufferID framebufferPacked,
   1948                                          GLenum buffer,
   1949                                          GLint drawbuffer,
   1950                                          const GLfloat *value,
   1951                                          angle::ParamCapture *paramCapture);
   1952 void CaptureClearNamedFramebufferiv_value(const State &glState,
   1953                                          bool isCallValid,
   1954                                          FramebufferID framebufferPacked,
   1955                                          GLenum buffer,
   1956                                          GLint drawbuffer,
   1957                                          const GLint *value,
   1958                                          angle::ParamCapture *paramCapture);
   1959 void CaptureClearNamedFramebufferuiv_value(const State &glState,
   1960                                           bool isCallValid,
   1961                                           FramebufferID framebufferPacked,
   1962                                           GLenum buffer,
   1963                                           GLint drawbuffer,
   1964                                           const GLuint *value,
   1965                                           angle::ParamCapture *paramCapture);
   1966 void CaptureCompressedTextureSubImage1D_data(const State &glState,
   1967                                             bool isCallValid,
   1968                                             TextureID texturePacked,
   1969                                             GLint level,
   1970                                             GLint xoffset,
   1971                                             GLsizei width,
   1972                                             GLenum format,
   1973                                             GLsizei imageSize,
   1974                                             const void *data,
   1975                                             angle::ParamCapture *paramCapture);
   1976 void CaptureCompressedTextureSubImage2D_data(const State &glState,
   1977                                             bool isCallValid,
   1978                                             TextureID texturePacked,
   1979                                             GLint level,
   1980                                             GLint xoffset,
   1981                                             GLint yoffset,
   1982                                             GLsizei width,
   1983                                             GLsizei height,
   1984                                             GLenum format,
   1985                                             GLsizei imageSize,
   1986                                             const void *data,
   1987                                             angle::ParamCapture *paramCapture);
   1988 void CaptureCompressedTextureSubImage3D_data(const State &glState,
   1989                                             bool isCallValid,
   1990                                             TextureID texturePacked,
   1991                                             GLint level,
   1992                                             GLint xoffset,
   1993                                             GLint yoffset,
   1994                                             GLint zoffset,
   1995                                             GLsizei width,
   1996                                             GLsizei height,
   1997                                             GLsizei depth,
   1998                                             GLenum format,
   1999                                             GLsizei imageSize,
   2000                                             const void *data,
   2001                                             angle::ParamCapture *paramCapture);
   2002 void CaptureCreateBuffers_buffersPacked(const State &glState,
   2003                                        bool isCallValid,
   2004                                        GLsizei n,
   2005                                        BufferID *buffersPacked,
   2006                                        angle::ParamCapture *paramCapture);
   2007 void CaptureCreateFramebuffers_framebuffers(const State &glState,
   2008                                            bool isCallValid,
   2009                                            GLsizei n,
   2010                                            GLuint *framebuffers,
   2011                                            angle::ParamCapture *paramCapture);
   2012 void CaptureCreateProgramPipelines_pipelines(const State &glState,
   2013                                             bool isCallValid,
   2014                                             GLsizei n,
   2015                                             GLuint *pipelines,
   2016                                             angle::ParamCapture *paramCapture);
   2017 void CaptureCreateQueries_ids(const State &glState,
   2018                              bool isCallValid,
   2019                              GLenum target,
   2020                              GLsizei n,
   2021                              GLuint *ids,
   2022                              angle::ParamCapture *paramCapture);
   2023 void CaptureCreateRenderbuffers_renderbuffersPacked(const State &glState,
   2024                                                    bool isCallValid,
   2025                                                    GLsizei n,
   2026                                                    RenderbufferID *renderbuffersPacked,
   2027                                                    angle::ParamCapture *paramCapture);
   2028 void CaptureCreateSamplers_samplers(const State &glState,
   2029                                    bool isCallValid,
   2030                                    GLsizei n,
   2031                                    GLuint *samplers,
   2032                                    angle::ParamCapture *paramCapture);
   2033 void CaptureCreateTextures_textures(const State &glState,
   2034                                    bool isCallValid,
   2035                                    GLenum target,
   2036                                    GLsizei n,
   2037                                    GLuint *textures,
   2038                                    angle::ParamCapture *paramCapture);
   2039 void CaptureCreateTransformFeedbacks_ids(const State &glState,
   2040                                         bool isCallValid,
   2041                                         GLsizei n,
   2042                                         GLuint *ids,
   2043                                         angle::ParamCapture *paramCapture);
   2044 void CaptureCreateVertexArrays_arraysPacked(const State &glState,
   2045                                            bool isCallValid,
   2046                                            GLsizei n,
   2047                                            VertexArrayID *arraysPacked,
   2048                                            angle::ParamCapture *paramCapture);
   2049 void CaptureGetCompressedTextureImage_pixels(const State &glState,
   2050                                             bool isCallValid,
   2051                                             TextureID texturePacked,
   2052                                             GLint level,
   2053                                             GLsizei bufSize,
   2054                                             void *pixels,
   2055                                             angle::ParamCapture *paramCapture);
   2056 void CaptureGetCompressedTextureSubImage_pixels(const State &glState,
   2057                                                bool isCallValid,
   2058                                                TextureID texturePacked,
   2059                                                GLint level,
   2060                                                GLint xoffset,
   2061                                                GLint yoffset,
   2062                                                GLint zoffset,
   2063                                                GLsizei width,
   2064                                                GLsizei height,
   2065                                                GLsizei depth,
   2066                                                GLsizei bufSize,
   2067                                                void *pixels,
   2068                                                angle::ParamCapture *paramCapture);
   2069 void CaptureGetNamedBufferParameteri64v_params(const State &glState,
   2070                                               bool isCallValid,
   2071                                               BufferID bufferPacked,
   2072                                               GLenum pname,
   2073                                               GLint64 *params,
   2074                                               angle::ParamCapture *paramCapture);
   2075 void CaptureGetNamedBufferParameteriv_params(const State &glState,
   2076                                             bool isCallValid,
   2077                                             BufferID bufferPacked,
   2078                                             GLenum pname,
   2079                                             GLint *params,
   2080                                             angle::ParamCapture *paramCapture);
   2081 void CaptureGetNamedBufferPointerv_params(const State &glState,
   2082                                          bool isCallValid,
   2083                                          BufferID bufferPacked,
   2084                                          GLenum pname,
   2085                                          void **params,
   2086                                          angle::ParamCapture *paramCapture);
   2087 void CaptureGetNamedBufferSubData_data(const State &glState,
   2088                                       bool isCallValid,
   2089                                       BufferID bufferPacked,
   2090                                       GLintptr offset,
   2091                                       GLsizeiptr size,
   2092                                       void *data,
   2093                                       angle::ParamCapture *paramCapture);
   2094 void CaptureGetNamedFramebufferAttachmentParameteriv_params(const State &glState,
   2095                                                            bool isCallValid,
   2096                                                            FramebufferID framebufferPacked,
   2097                                                            GLenum attachment,
   2098                                                            GLenum pname,
   2099                                                            GLint *params,
   2100                                                            angle::ParamCapture *paramCapture);
   2101 void CaptureGetNamedFramebufferParameteriv_param(const State &glState,
   2102                                                 bool isCallValid,
   2103                                                 FramebufferID framebufferPacked,
   2104                                                 GLenum pname,
   2105                                                 GLint *param,
   2106                                                 angle::ParamCapture *paramCapture);
   2107 void CaptureGetNamedRenderbufferParameteriv_params(const State &glState,
   2108                                                   bool isCallValid,
   2109                                                   RenderbufferID renderbufferPacked,
   2110                                                   GLenum pname,
   2111                                                   GLint *params,
   2112                                                   angle::ParamCapture *paramCapture);
   2113 void CaptureGetTextureImage_pixels(const State &glState,
   2114                                   bool isCallValid,
   2115                                   TextureID texturePacked,
   2116                                   GLint level,
   2117                                   GLenum format,
   2118                                   GLenum type,
   2119                                   GLsizei bufSize,
   2120                                   void *pixels,
   2121                                   angle::ParamCapture *paramCapture);
   2122 void CaptureGetTextureLevelParameterfv_params(const State &glState,
   2123                                              bool isCallValid,
   2124                                              TextureID texturePacked,
   2125                                              GLint level,
   2126                                              GLenum pname,
   2127                                              GLfloat *params,
   2128                                              angle::ParamCapture *paramCapture);
   2129 void CaptureGetTextureLevelParameteriv_params(const State &glState,
   2130                                              bool isCallValid,
   2131                                              TextureID texturePacked,
   2132                                              GLint level,
   2133                                              GLenum pname,
   2134                                              GLint *params,
   2135                                              angle::ParamCapture *paramCapture);
   2136 void CaptureGetTextureParameterIiv_params(const State &glState,
   2137                                          bool isCallValid,
   2138                                          TextureID texturePacked,
   2139                                          GLenum pname,
   2140                                          GLint *params,
   2141                                          angle::ParamCapture *paramCapture);
   2142 void CaptureGetTextureParameterIuiv_params(const State &glState,
   2143                                           bool isCallValid,
   2144                                           TextureID texturePacked,
   2145                                           GLenum pname,
   2146                                           GLuint *params,
   2147                                           angle::ParamCapture *paramCapture);
   2148 void CaptureGetTextureParameterfv_params(const State &glState,
   2149                                         bool isCallValid,
   2150                                         TextureID texturePacked,
   2151                                         GLenum pname,
   2152                                         GLfloat *params,
   2153                                         angle::ParamCapture *paramCapture);
   2154 void CaptureGetTextureParameteriv_params(const State &glState,
   2155                                         bool isCallValid,
   2156                                         TextureID texturePacked,
   2157                                         GLenum pname,
   2158                                         GLint *params,
   2159                                         angle::ParamCapture *paramCapture);
   2160 void CaptureGetTextureSubImage_pixels(const State &glState,
   2161                                      bool isCallValid,
   2162                                      TextureID texturePacked,
   2163                                      GLint level,
   2164                                      GLint xoffset,
   2165                                      GLint yoffset,
   2166                                      GLint zoffset,
   2167                                      GLsizei width,
   2168                                      GLsizei height,
   2169                                      GLsizei depth,
   2170                                      GLenum format,
   2171                                      GLenum type,
   2172                                      GLsizei bufSize,
   2173                                      void *pixels,
   2174                                      angle::ParamCapture *paramCapture);
   2175 void CaptureGetTransformFeedbacki64_v_param(const State &glState,
   2176                                            bool isCallValid,
   2177                                            GLuint xfb,
   2178                                            GLenum pname,
   2179                                            GLuint index,
   2180                                            GLint64 *param,
   2181                                            angle::ParamCapture *paramCapture);
   2182 void CaptureGetTransformFeedbacki_v_param(const State &glState,
   2183                                          bool isCallValid,
   2184                                          GLuint xfb,
   2185                                          GLenum pname,
   2186                                          GLuint index,
   2187                                          GLint *param,
   2188                                          angle::ParamCapture *paramCapture);
   2189 void CaptureGetTransformFeedbackiv_param(const State &glState,
   2190                                         bool isCallValid,
   2191                                         GLuint xfb,
   2192                                         GLenum pname,
   2193                                         GLint *param,
   2194                                         angle::ParamCapture *paramCapture);
   2195 void CaptureGetVertexArrayIndexed64iv_param(const State &glState,
   2196                                            bool isCallValid,
   2197                                            VertexArrayID vaobjPacked,
   2198                                            GLuint index,
   2199                                            GLenum pname,
   2200                                            GLint64 *param,
   2201                                            angle::ParamCapture *paramCapture);
   2202 void CaptureGetVertexArrayIndexediv_param(const State &glState,
   2203                                          bool isCallValid,
   2204                                          VertexArrayID vaobjPacked,
   2205                                          GLuint index,
   2206                                          GLenum pname,
   2207                                          GLint *param,
   2208                                          angle::ParamCapture *paramCapture);
   2209 void CaptureGetVertexArrayiv_param(const State &glState,
   2210                                   bool isCallValid,
   2211                                   VertexArrayID vaobjPacked,
   2212                                   GLenum pname,
   2213                                   GLint *param,
   2214                                   angle::ParamCapture *paramCapture);
   2215 void CaptureGetnColorTable_table(const State &glState,
   2216                                 bool isCallValid,
   2217                                 GLenum target,
   2218                                 GLenum format,
   2219                                 GLenum type,
   2220                                 GLsizei bufSize,
   2221                                 void *table,
   2222                                 angle::ParamCapture *paramCapture);
   2223 void CaptureGetnCompressedTexImage_pixels(const State &glState,
   2224                                          bool isCallValid,
   2225                                          GLenum target,
   2226                                          GLint lod,
   2227                                          GLsizei bufSize,
   2228                                          void *pixels,
   2229                                          angle::ParamCapture *paramCapture);
   2230 void CaptureGetnConvolutionFilter_image(const State &glState,
   2231                                        bool isCallValid,
   2232                                        GLenum target,
   2233                                        GLenum format,
   2234                                        GLenum type,
   2235                                        GLsizei bufSize,
   2236                                        void *image,
   2237                                        angle::ParamCapture *paramCapture);
   2238 void CaptureGetnHistogram_values(const State &glState,
   2239                                 bool isCallValid,
   2240                                 GLenum target,
   2241                                 GLboolean reset,
   2242                                 GLenum format,
   2243                                 GLenum type,
   2244                                 GLsizei bufSize,
   2245                                 void *values,
   2246                                 angle::ParamCapture *paramCapture);
   2247 void CaptureGetnMapdv_v(const State &glState,
   2248                        bool isCallValid,
   2249                        GLenum target,
   2250                        GLenum query,
   2251                        GLsizei bufSize,
   2252                        GLdouble *v,
   2253                        angle::ParamCapture *paramCapture);
   2254 void CaptureGetnMapfv_v(const State &glState,
   2255                        bool isCallValid,
   2256                        GLenum target,
   2257                        GLenum query,
   2258                        GLsizei bufSize,
   2259                        GLfloat *v,
   2260                        angle::ParamCapture *paramCapture);
   2261 void CaptureGetnMapiv_v(const State &glState,
   2262                        bool isCallValid,
   2263                        GLenum target,
   2264                        GLenum query,
   2265                        GLsizei bufSize,
   2266                        GLint *v,
   2267                        angle::ParamCapture *paramCapture);
   2268 void CaptureGetnMinmax_values(const State &glState,
   2269                              bool isCallValid,
   2270                              GLenum target,
   2271                              GLboolean reset,
   2272                              GLenum format,
   2273                              GLenum type,
   2274                              GLsizei bufSize,
   2275                              void *values,
   2276                              angle::ParamCapture *paramCapture);
   2277 void CaptureGetnPixelMapfv_values(const State &glState,
   2278                                  bool isCallValid,
   2279                                  GLenum map,
   2280                                  GLsizei bufSize,
   2281                                  GLfloat *values,
   2282                                  angle::ParamCapture *paramCapture);
   2283 void CaptureGetnPixelMapuiv_values(const State &glState,
   2284                                   bool isCallValid,
   2285                                   GLenum map,
   2286                                   GLsizei bufSize,
   2287                                   GLuint *values,
   2288                                   angle::ParamCapture *paramCapture);
   2289 void CaptureGetnPixelMapusv_values(const State &glState,
   2290                                   bool isCallValid,
   2291                                   GLenum map,
   2292                                   GLsizei bufSize,
   2293                                   GLushort *values,
   2294                                   angle::ParamCapture *paramCapture);
   2295 void CaptureGetnPolygonStipple_pattern(const State &glState,
   2296                                       bool isCallValid,
   2297                                       GLsizei bufSize,
   2298                                       GLubyte *pattern,
   2299                                       angle::ParamCapture *paramCapture);
   2300 void CaptureGetnSeparableFilter_row(const State &glState,
   2301                                    bool isCallValid,
   2302                                    GLenum target,
   2303                                    GLenum format,
   2304                                    GLenum type,
   2305                                    GLsizei rowBufSize,
   2306                                    void *row,
   2307                                    GLsizei columnBufSize,
   2308                                    void *column,
   2309                                    void *span,
   2310                                    angle::ParamCapture *paramCapture);
   2311 void CaptureGetnSeparableFilter_column(const State &glState,
   2312                                       bool isCallValid,
   2313                                       GLenum target,
   2314                                       GLenum format,
   2315                                       GLenum type,
   2316                                       GLsizei rowBufSize,
   2317                                       void *row,
   2318                                       GLsizei columnBufSize,
   2319                                       void *column,
   2320                                       void *span,
   2321                                       angle::ParamCapture *paramCapture);
   2322 void CaptureGetnSeparableFilter_span(const State &glState,
   2323                                     bool isCallValid,
   2324                                     GLenum target,
   2325                                     GLenum format,
   2326                                     GLenum type,
   2327                                     GLsizei rowBufSize,
   2328                                     void *row,
   2329                                     GLsizei columnBufSize,
   2330                                     void *column,
   2331                                     void *span,
   2332                                     angle::ParamCapture *paramCapture);
   2333 void CaptureGetnTexImage_pixels(const State &glState,
   2334                                bool isCallValid,
   2335                                GLenum target,
   2336                                GLint level,
   2337                                GLenum format,
   2338                                GLenum type,
   2339                                GLsizei bufSize,
   2340                                void *pixels,
   2341                                angle::ParamCapture *paramCapture);
   2342 void CaptureGetnUniformdv_params(const State &glState,
   2343                                 bool isCallValid,
   2344                                 ShaderProgramID programPacked,
   2345                                 UniformLocation locationPacked,
   2346                                 GLsizei bufSize,
   2347                                 GLdouble *params,
   2348                                 angle::ParamCapture *paramCapture);
   2349 void CaptureInvalidateNamedFramebufferData_attachments(const State &glState,
   2350                                                       bool isCallValid,
   2351                                                       FramebufferID framebufferPacked,
   2352                                                       GLsizei numAttachments,
   2353                                                       const GLenum *attachments,
   2354                                                       angle::ParamCapture *paramCapture);
   2355 void CaptureInvalidateNamedFramebufferSubData_attachments(const State &glState,
   2356                                                          bool isCallValid,
   2357                                                          FramebufferID framebufferPacked,
   2358                                                          GLsizei numAttachments,
   2359                                                          const GLenum *attachments,
   2360                                                          GLint x,
   2361                                                          GLint y,
   2362                                                          GLsizei width,
   2363                                                          GLsizei height,
   2364                                                          angle::ParamCapture *paramCapture);
   2365 void CaptureNamedBufferData_data(const State &glState,
   2366                                 bool isCallValid,
   2367                                 BufferID bufferPacked,
   2368                                 GLsizeiptr size,
   2369                                 const void *data,
   2370                                 GLenum usage,
   2371                                 angle::ParamCapture *paramCapture);
   2372 void CaptureNamedBufferStorage_data(const State &glState,
   2373                                    bool isCallValid,
   2374                                    BufferID bufferPacked,
   2375                                    GLsizeiptr size,
   2376                                    const void *data,
   2377                                    GLbitfield flags,
   2378                                    angle::ParamCapture *paramCapture);
   2379 void CaptureNamedBufferSubData_data(const State &glState,
   2380                                    bool isCallValid,
   2381                                    BufferID bufferPacked,
   2382                                    GLintptr offset,
   2383                                    GLsizeiptr size,
   2384                                    const void *data,
   2385                                    angle::ParamCapture *paramCapture);
   2386 void CaptureNamedFramebufferDrawBuffers_bufs(const State &glState,
   2387                                             bool isCallValid,
   2388                                             FramebufferID framebufferPacked,
   2389                                             GLsizei n,
   2390                                             const GLenum *bufs,
   2391                                             angle::ParamCapture *paramCapture);
   2392 void CaptureTextureParameterIiv_params(const State &glState,
   2393                                       bool isCallValid,
   2394                                       TextureID texturePacked,
   2395                                       GLenum pname,
   2396                                       const GLint *params,
   2397                                       angle::ParamCapture *paramCapture);
   2398 void CaptureTextureParameterIuiv_params(const State &glState,
   2399                                        bool isCallValid,
   2400                                        TextureID texturePacked,
   2401                                        GLenum pname,
   2402                                        const GLuint *params,
   2403                                        angle::ParamCapture *paramCapture);
   2404 void CaptureTextureParameterfv_param(const State &glState,
   2405                                     bool isCallValid,
   2406                                     TextureID texturePacked,
   2407                                     GLenum pname,
   2408                                     const GLfloat *param,
   2409                                     angle::ParamCapture *paramCapture);
   2410 void CaptureTextureParameteriv_param(const State &glState,
   2411                                     bool isCallValid,
   2412                                     TextureID texturePacked,
   2413                                     GLenum pname,
   2414                                     const GLint *param,
   2415                                     angle::ParamCapture *paramCapture);
   2416 void CaptureTextureSubImage1D_pixels(const State &glState,
   2417                                     bool isCallValid,
   2418                                     TextureID texturePacked,
   2419                                     GLint level,
   2420                                     GLint xoffset,
   2421                                     GLsizei width,
   2422                                     GLenum format,
   2423                                     GLenum type,
   2424                                     const void *pixels,
   2425                                     angle::ParamCapture *paramCapture);
   2426 void CaptureTextureSubImage2D_pixels(const State &glState,
   2427                                     bool isCallValid,
   2428                                     TextureID texturePacked,
   2429                                     GLint level,
   2430                                     GLint xoffset,
   2431                                     GLint yoffset,
   2432                                     GLsizei width,
   2433                                     GLsizei height,
   2434                                     GLenum format,
   2435                                     GLenum type,
   2436                                     const void *pixels,
   2437                                     angle::ParamCapture *paramCapture);
   2438 void CaptureTextureSubImage3D_pixels(const State &glState,
   2439                                     bool isCallValid,
   2440                                     TextureID texturePacked,
   2441                                     GLint level,
   2442                                     GLint xoffset,
   2443                                     GLint yoffset,
   2444                                     GLint zoffset,
   2445                                     GLsizei width,
   2446                                     GLsizei height,
   2447                                     GLsizei depth,
   2448                                     GLenum format,
   2449                                     GLenum type,
   2450                                     const void *pixels,
   2451                                     angle::ParamCapture *paramCapture);
   2452 void CaptureVertexArrayVertexBuffers_buffersPacked(const State &glState,
   2453                                                   bool isCallValid,
   2454                                                   VertexArrayID vaobjPacked,
   2455                                                   GLuint first,
   2456                                                   GLsizei count,
   2457                                                   const BufferID *buffersPacked,
   2458                                                   const GLintptr *offsets,
   2459                                                   const GLsizei *strides,
   2460                                                   angle::ParamCapture *paramCapture);
   2461 void CaptureVertexArrayVertexBuffers_offsets(const State &glState,
   2462                                             bool isCallValid,
   2463                                             VertexArrayID vaobjPacked,
   2464                                             GLuint first,
   2465                                             GLsizei count,
   2466                                             const BufferID *buffersPacked,
   2467                                             const GLintptr *offsets,
   2468                                             const GLsizei *strides,
   2469                                             angle::ParamCapture *paramCapture);
   2470 void CaptureVertexArrayVertexBuffers_strides(const State &glState,
   2471                                             bool isCallValid,
   2472                                             VertexArrayID vaobjPacked,
   2473                                             GLuint first,
   2474                                             GLsizei count,
   2475                                             const BufferID *buffersPacked,
   2476                                             const GLintptr *offsets,
   2477                                             const GLsizei *strides,
   2478                                             angle::ParamCapture *paramCapture);
   2479 
   2480 // GL 4.6
   2481 void CaptureMultiDrawArraysIndirectCount_indirect(const State &glState,
   2482                                                  bool isCallValid,
   2483                                                  GLenum mode,
   2484                                                  const void *indirect,
   2485                                                  GLintptr drawcount,
   2486                                                  GLsizei maxdrawcount,
   2487                                                  GLsizei stride,
   2488                                                  angle::ParamCapture *paramCapture);
   2489 void CaptureMultiDrawElementsIndirectCount_indirect(const State &glState,
   2490                                                    bool isCallValid,
   2491                                                    GLenum mode,
   2492                                                    GLenum type,
   2493                                                    const void *indirect,
   2494                                                    GLintptr drawcount,
   2495                                                    GLsizei maxdrawcount,
   2496                                                    GLsizei stride,
   2497                                                    angle::ParamCapture *paramCapture);
   2498 void CaptureSpecializeShader_pEntryPoint(const State &glState,
   2499                                         bool isCallValid,
   2500                                         GLuint shader,
   2501                                         const GLchar *pEntryPoint,
   2502                                         GLuint numSpecializationConstants,
   2503                                         const GLuint *pConstantIndex,
   2504                                         const GLuint *pConstantValue,
   2505                                         angle::ParamCapture *paramCapture);
   2506 void CaptureSpecializeShader_pConstantIndex(const State &glState,
   2507                                            bool isCallValid,
   2508                                            GLuint shader,
   2509                                            const GLchar *pEntryPoint,
   2510                                            GLuint numSpecializationConstants,
   2511                                            const GLuint *pConstantIndex,
   2512                                            const GLuint *pConstantValue,
   2513                                            angle::ParamCapture *paramCapture);
   2514 void CaptureSpecializeShader_pConstantValue(const State &glState,
   2515                                            bool isCallValid,
   2516                                            GLuint shader,
   2517                                            const GLchar *pEntryPoint,
   2518                                            GLuint numSpecializationConstants,
   2519                                            const GLuint *pConstantIndex,
   2520                                            const GLuint *pConstantValue,
   2521                                            angle::ParamCapture *paramCapture);
   2522 }  // namespace gl
   2523 
   2524 #endif  // LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_