tor-browser

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

capture_gles_3_0_autogen.h (65960B)


      1 // GENERATED FILE - DO NOT EDIT.
      2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
      3 //
      4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
      5 // Use of this source code is governed by a BSD-style license that can be
      6 // found in the LICENSE file.
      7 //
      8 // capture_gles_3_0_autogen.h:
      9 //   Capture functions for the OpenGL ES 3.0 entry points.
     10 
     11 #ifndef LIBANGLE_CAPTURE_GLES_3_0_AUTOGEN_H_
     12 #define LIBANGLE_CAPTURE_GLES_3_0_AUTOGEN_H_
     13 
     14 #include "common/PackedEnums.h"
     15 #include "libANGLE/capture/FrameCapture.h"
     16 
     17 namespace gl
     18 {
     19 
     20 // Method Captures
     21 
     22 angle::CallCapture CaptureBeginQuery(const State &glState,
     23                                     bool isCallValid,
     24                                     QueryType targetPacked,
     25                                     QueryID idPacked);
     26 angle::CallCapture CaptureBeginTransformFeedback(const State &glState,
     27                                                 bool isCallValid,
     28                                                 PrimitiveMode primitiveModePacked);
     29 angle::CallCapture CaptureBindBufferBase(const State &glState,
     30                                         bool isCallValid,
     31                                         BufferBinding targetPacked,
     32                                         GLuint index,
     33                                         BufferID bufferPacked);
     34 angle::CallCapture CaptureBindBufferRange(const State &glState,
     35                                          bool isCallValid,
     36                                          BufferBinding targetPacked,
     37                                          GLuint index,
     38                                          BufferID bufferPacked,
     39                                          GLintptr offset,
     40                                          GLsizeiptr size);
     41 angle::CallCapture CaptureBindSampler(const State &glState,
     42                                      bool isCallValid,
     43                                      GLuint unit,
     44                                      SamplerID samplerPacked);
     45 angle::CallCapture CaptureBindTransformFeedback(const State &glState,
     46                                                bool isCallValid,
     47                                                GLenum target,
     48                                                TransformFeedbackID idPacked);
     49 angle::CallCapture CaptureBindVertexArray(const State &glState,
     50                                          bool isCallValid,
     51                                          VertexArrayID arrayPacked);
     52 angle::CallCapture CaptureBlitFramebuffer(const State &glState,
     53                                          bool isCallValid,
     54                                          GLint srcX0,
     55                                          GLint srcY0,
     56                                          GLint srcX1,
     57                                          GLint srcY1,
     58                                          GLint dstX0,
     59                                          GLint dstY0,
     60                                          GLint dstX1,
     61                                          GLint dstY1,
     62                                          GLbitfield mask,
     63                                          GLenum filter);
     64 angle::CallCapture CaptureClearBufferfi(const State &glState,
     65                                        bool isCallValid,
     66                                        GLenum buffer,
     67                                        GLint drawbuffer,
     68                                        GLfloat depth,
     69                                        GLint stencil);
     70 angle::CallCapture CaptureClearBufferfv(const State &glState,
     71                                        bool isCallValid,
     72                                        GLenum buffer,
     73                                        GLint drawbuffer,
     74                                        const GLfloat *value);
     75 angle::CallCapture CaptureClearBufferiv(const State &glState,
     76                                        bool isCallValid,
     77                                        GLenum buffer,
     78                                        GLint drawbuffer,
     79                                        const GLint *value);
     80 angle::CallCapture CaptureClearBufferuiv(const State &glState,
     81                                         bool isCallValid,
     82                                         GLenum buffer,
     83                                         GLint drawbuffer,
     84                                         const GLuint *value);
     85 angle::CallCapture CaptureClientWaitSync(const State &glState,
     86                                         bool isCallValid,
     87                                         GLsync sync,
     88                                         GLbitfield flags,
     89                                         GLuint64 timeout,
     90                                         GLenum returnValue);
     91 angle::CallCapture CaptureCompressedTexImage3D(const State &glState,
     92                                               bool isCallValid,
     93                                               TextureTarget targetPacked,
     94                                               GLint level,
     95                                               GLenum internalformat,
     96                                               GLsizei width,
     97                                               GLsizei height,
     98                                               GLsizei depth,
     99                                               GLint border,
    100                                               GLsizei imageSize,
    101                                               const void *data);
    102 angle::CallCapture CaptureCompressedTexSubImage3D(const State &glState,
    103                                                  bool isCallValid,
    104                                                  TextureTarget targetPacked,
    105                                                  GLint level,
    106                                                  GLint xoffset,
    107                                                  GLint yoffset,
    108                                                  GLint zoffset,
    109                                                  GLsizei width,
    110                                                  GLsizei height,
    111                                                  GLsizei depth,
    112                                                  GLenum format,
    113                                                  GLsizei imageSize,
    114                                                  const void *data);
    115 angle::CallCapture CaptureCopyBufferSubData(const State &glState,
    116                                            bool isCallValid,
    117                                            BufferBinding readTargetPacked,
    118                                            BufferBinding writeTargetPacked,
    119                                            GLintptr readOffset,
    120                                            GLintptr writeOffset,
    121                                            GLsizeiptr size);
    122 angle::CallCapture CaptureCopyTexSubImage3D(const State &glState,
    123                                            bool isCallValid,
    124                                            TextureTarget targetPacked,
    125                                            GLint level,
    126                                            GLint xoffset,
    127                                            GLint yoffset,
    128                                            GLint zoffset,
    129                                            GLint x,
    130                                            GLint y,
    131                                            GLsizei width,
    132                                            GLsizei height);
    133 angle::CallCapture CaptureDeleteQueries(const State &glState,
    134                                        bool isCallValid,
    135                                        GLsizei n,
    136                                        const QueryID *idsPacked);
    137 angle::CallCapture CaptureDeleteSamplers(const State &glState,
    138                                         bool isCallValid,
    139                                         GLsizei count,
    140                                         const SamplerID *samplersPacked);
    141 angle::CallCapture CaptureDeleteSync(const State &glState, bool isCallValid, GLsync sync);
    142 angle::CallCapture CaptureDeleteTransformFeedbacks(const State &glState,
    143                                                   bool isCallValid,
    144                                                   GLsizei n,
    145                                                   const TransformFeedbackID *idsPacked);
    146 angle::CallCapture CaptureDeleteVertexArrays(const State &glState,
    147                                             bool isCallValid,
    148                                             GLsizei n,
    149                                             const VertexArrayID *arraysPacked);
    150 angle::CallCapture CaptureDrawArraysInstanced(const State &glState,
    151                                              bool isCallValid,
    152                                              PrimitiveMode modePacked,
    153                                              GLint first,
    154                                              GLsizei count,
    155                                              GLsizei instancecount);
    156 angle::CallCapture CaptureDrawBuffers(const State &glState,
    157                                      bool isCallValid,
    158                                      GLsizei n,
    159                                      const GLenum *bufs);
    160 angle::CallCapture CaptureDrawElementsInstanced(const State &glState,
    161                                                bool isCallValid,
    162                                                PrimitiveMode modePacked,
    163                                                GLsizei count,
    164                                                DrawElementsType typePacked,
    165                                                const void *indices,
    166                                                GLsizei instancecount);
    167 angle::CallCapture CaptureDrawRangeElements(const State &glState,
    168                                            bool isCallValid,
    169                                            PrimitiveMode modePacked,
    170                                            GLuint start,
    171                                            GLuint end,
    172                                            GLsizei count,
    173                                            DrawElementsType typePacked,
    174                                            const void *indices);
    175 angle::CallCapture CaptureEndQuery(const State &glState, bool isCallValid, QueryType targetPacked);
    176 angle::CallCapture CaptureEndTransformFeedback(const State &glState, bool isCallValid);
    177 angle::CallCapture CaptureFenceSync(const State &glState,
    178                                    bool isCallValid,
    179                                    GLenum condition,
    180                                    GLbitfield flags,
    181                                    GLsync returnValue);
    182 angle::CallCapture CaptureFlushMappedBufferRange(const State &glState,
    183                                                 bool isCallValid,
    184                                                 BufferBinding targetPacked,
    185                                                 GLintptr offset,
    186                                                 GLsizeiptr length);
    187 angle::CallCapture CaptureFramebufferTextureLayer(const State &glState,
    188                                                  bool isCallValid,
    189                                                  GLenum target,
    190                                                  GLenum attachment,
    191                                                  TextureID texturePacked,
    192                                                  GLint level,
    193                                                  GLint layer);
    194 angle::CallCapture CaptureGenQueries(const State &glState,
    195                                     bool isCallValid,
    196                                     GLsizei n,
    197                                     QueryID *idsPacked);
    198 angle::CallCapture CaptureGenSamplers(const State &glState,
    199                                      bool isCallValid,
    200                                      GLsizei count,
    201                                      SamplerID *samplersPacked);
    202 angle::CallCapture CaptureGenTransformFeedbacks(const State &glState,
    203                                                bool isCallValid,
    204                                                GLsizei n,
    205                                                TransformFeedbackID *idsPacked);
    206 angle::CallCapture CaptureGenVertexArrays(const State &glState,
    207                                          bool isCallValid,
    208                                          GLsizei n,
    209                                          VertexArrayID *arraysPacked);
    210 angle::CallCapture CaptureGetActiveUniformBlockName(const State &glState,
    211                                                    bool isCallValid,
    212                                                    ShaderProgramID programPacked,
    213                                                    UniformBlockIndex uniformBlockIndexPacked,
    214                                                    GLsizei bufSize,
    215                                                    GLsizei *length,
    216                                                    GLchar *uniformBlockName);
    217 angle::CallCapture CaptureGetActiveUniformBlockiv(const State &glState,
    218                                                  bool isCallValid,
    219                                                  ShaderProgramID programPacked,
    220                                                  UniformBlockIndex uniformBlockIndexPacked,
    221                                                  GLenum pname,
    222                                                  GLint *params);
    223 angle::CallCapture CaptureGetActiveUniformsiv(const State &glState,
    224                                              bool isCallValid,
    225                                              ShaderProgramID programPacked,
    226                                              GLsizei uniformCount,
    227                                              const GLuint *uniformIndices,
    228                                              GLenum pname,
    229                                              GLint *params);
    230 angle::CallCapture CaptureGetBufferParameteri64v(const State &glState,
    231                                                 bool isCallValid,
    232                                                 BufferBinding targetPacked,
    233                                                 GLenum pname,
    234                                                 GLint64 *params);
    235 angle::CallCapture CaptureGetBufferPointerv(const State &glState,
    236                                            bool isCallValid,
    237                                            BufferBinding targetPacked,
    238                                            GLenum pname,
    239                                            void **params);
    240 angle::CallCapture CaptureGetFragDataLocation(const State &glState,
    241                                              bool isCallValid,
    242                                              ShaderProgramID programPacked,
    243                                              const GLchar *name,
    244                                              GLint returnValue);
    245 angle::CallCapture CaptureGetInteger64i_v(const State &glState,
    246                                          bool isCallValid,
    247                                          GLenum target,
    248                                          GLuint index,
    249                                          GLint64 *data);
    250 angle::CallCapture CaptureGetInteger64v(const State &glState,
    251                                        bool isCallValid,
    252                                        GLenum pname,
    253                                        GLint64 *data);
    254 angle::CallCapture CaptureGetIntegeri_v(const State &glState,
    255                                        bool isCallValid,
    256                                        GLenum target,
    257                                        GLuint index,
    258                                        GLint *data);
    259 angle::CallCapture CaptureGetInternalformativ(const State &glState,
    260                                              bool isCallValid,
    261                                              GLenum target,
    262                                              GLenum internalformat,
    263                                              GLenum pname,
    264                                              GLsizei count,
    265                                              GLint *params);
    266 angle::CallCapture CaptureGetProgramBinary(const State &glState,
    267                                           bool isCallValid,
    268                                           ShaderProgramID programPacked,
    269                                           GLsizei bufSize,
    270                                           GLsizei *length,
    271                                           GLenum *binaryFormat,
    272                                           void *binary);
    273 angle::CallCapture CaptureGetQueryObjectuiv(const State &glState,
    274                                            bool isCallValid,
    275                                            QueryID idPacked,
    276                                            GLenum pname,
    277                                            GLuint *params);
    278 angle::CallCapture CaptureGetQueryiv(const State &glState,
    279                                     bool isCallValid,
    280                                     QueryType targetPacked,
    281                                     GLenum pname,
    282                                     GLint *params);
    283 angle::CallCapture CaptureGetSamplerParameterfv(const State &glState,
    284                                                bool isCallValid,
    285                                                SamplerID samplerPacked,
    286                                                GLenum pname,
    287                                                GLfloat *params);
    288 angle::CallCapture CaptureGetSamplerParameteriv(const State &glState,
    289                                                bool isCallValid,
    290                                                SamplerID samplerPacked,
    291                                                GLenum pname,
    292                                                GLint *params);
    293 angle::CallCapture CaptureGetStringi(const State &glState,
    294                                     bool isCallValid,
    295                                     GLenum name,
    296                                     GLuint index,
    297                                     const GLubyte *returnValue);
    298 angle::CallCapture CaptureGetSynciv(const State &glState,
    299                                    bool isCallValid,
    300                                    GLsync sync,
    301                                    GLenum pname,
    302                                    GLsizei count,
    303                                    GLsizei *length,
    304                                    GLint *values);
    305 angle::CallCapture CaptureGetTransformFeedbackVarying(const State &glState,
    306                                                      bool isCallValid,
    307                                                      ShaderProgramID programPacked,
    308                                                      GLuint index,
    309                                                      GLsizei bufSize,
    310                                                      GLsizei *length,
    311                                                      GLsizei *size,
    312                                                      GLenum *type,
    313                                                      GLchar *name);
    314 angle::CallCapture CaptureGetUniformBlockIndex(const State &glState,
    315                                               bool isCallValid,
    316                                               ShaderProgramID programPacked,
    317                                               const GLchar *uniformBlockName,
    318                                               GLuint returnValue);
    319 angle::CallCapture CaptureGetUniformIndices(const State &glState,
    320                                            bool isCallValid,
    321                                            ShaderProgramID programPacked,
    322                                            GLsizei uniformCount,
    323                                            const GLchar *const *uniformNames,
    324                                            GLuint *uniformIndices);
    325 angle::CallCapture CaptureGetUniformuiv(const State &glState,
    326                                        bool isCallValid,
    327                                        ShaderProgramID programPacked,
    328                                        UniformLocation locationPacked,
    329                                        GLuint *params);
    330 angle::CallCapture CaptureGetVertexAttribIiv(const State &glState,
    331                                             bool isCallValid,
    332                                             GLuint index,
    333                                             GLenum pname,
    334                                             GLint *params);
    335 angle::CallCapture CaptureGetVertexAttribIuiv(const State &glState,
    336                                              bool isCallValid,
    337                                              GLuint index,
    338                                              GLenum pname,
    339                                              GLuint *params);
    340 angle::CallCapture CaptureInvalidateFramebuffer(const State &glState,
    341                                                bool isCallValid,
    342                                                GLenum target,
    343                                                GLsizei numAttachments,
    344                                                const GLenum *attachments);
    345 angle::CallCapture CaptureInvalidateSubFramebuffer(const State &glState,
    346                                                   bool isCallValid,
    347                                                   GLenum target,
    348                                                   GLsizei numAttachments,
    349                                                   const GLenum *attachments,
    350                                                   GLint x,
    351                                                   GLint y,
    352                                                   GLsizei width,
    353                                                   GLsizei height);
    354 angle::CallCapture CaptureIsQuery(const State &glState,
    355                                  bool isCallValid,
    356                                  QueryID idPacked,
    357                                  GLboolean returnValue);
    358 angle::CallCapture CaptureIsSampler(const State &glState,
    359                                    bool isCallValid,
    360                                    SamplerID samplerPacked,
    361                                    GLboolean returnValue);
    362 angle::CallCapture CaptureIsSync(const State &glState,
    363                                 bool isCallValid,
    364                                 GLsync sync,
    365                                 GLboolean returnValue);
    366 angle::CallCapture CaptureIsTransformFeedback(const State &glState,
    367                                              bool isCallValid,
    368                                              TransformFeedbackID idPacked,
    369                                              GLboolean returnValue);
    370 angle::CallCapture CaptureIsVertexArray(const State &glState,
    371                                        bool isCallValid,
    372                                        VertexArrayID arrayPacked,
    373                                        GLboolean returnValue);
    374 angle::CallCapture CaptureMapBufferRange(const State &glState,
    375                                         bool isCallValid,
    376                                         BufferBinding targetPacked,
    377                                         GLintptr offset,
    378                                         GLsizeiptr length,
    379                                         GLbitfield access,
    380                                         void *returnValue);
    381 angle::CallCapture CapturePauseTransformFeedback(const State &glState, bool isCallValid);
    382 angle::CallCapture CaptureProgramBinary(const State &glState,
    383                                        bool isCallValid,
    384                                        ShaderProgramID programPacked,
    385                                        GLenum binaryFormat,
    386                                        const void *binary,
    387                                        GLsizei length);
    388 angle::CallCapture CaptureProgramParameteri(const State &glState,
    389                                            bool isCallValid,
    390                                            ShaderProgramID programPacked,
    391                                            GLenum pname,
    392                                            GLint value);
    393 angle::CallCapture CaptureReadBuffer(const State &glState, bool isCallValid, GLenum src);
    394 angle::CallCapture CaptureRenderbufferStorageMultisample(const State &glState,
    395                                                         bool isCallValid,
    396                                                         GLenum target,
    397                                                         GLsizei samples,
    398                                                         GLenum internalformat,
    399                                                         GLsizei width,
    400                                                         GLsizei height);
    401 angle::CallCapture CaptureResumeTransformFeedback(const State &glState, bool isCallValid);
    402 angle::CallCapture CaptureSamplerParameterf(const State &glState,
    403                                            bool isCallValid,
    404                                            SamplerID samplerPacked,
    405                                            GLenum pname,
    406                                            GLfloat param);
    407 angle::CallCapture CaptureSamplerParameterfv(const State &glState,
    408                                             bool isCallValid,
    409                                             SamplerID samplerPacked,
    410                                             GLenum pname,
    411                                             const GLfloat *param);
    412 angle::CallCapture CaptureSamplerParameteri(const State &glState,
    413                                            bool isCallValid,
    414                                            SamplerID samplerPacked,
    415                                            GLenum pname,
    416                                            GLint param);
    417 angle::CallCapture CaptureSamplerParameteriv(const State &glState,
    418                                             bool isCallValid,
    419                                             SamplerID samplerPacked,
    420                                             GLenum pname,
    421                                             const GLint *param);
    422 angle::CallCapture CaptureTexImage3D(const State &glState,
    423                                     bool isCallValid,
    424                                     TextureTarget targetPacked,
    425                                     GLint level,
    426                                     GLint internalformat,
    427                                     GLsizei width,
    428                                     GLsizei height,
    429                                     GLsizei depth,
    430                                     GLint border,
    431                                     GLenum format,
    432                                     GLenum type,
    433                                     const void *pixels);
    434 angle::CallCapture CaptureTexStorage2D(const State &glState,
    435                                       bool isCallValid,
    436                                       TextureType targetPacked,
    437                                       GLsizei levels,
    438                                       GLenum internalformat,
    439                                       GLsizei width,
    440                                       GLsizei height);
    441 angle::CallCapture CaptureTexStorage3D(const State &glState,
    442                                       bool isCallValid,
    443                                       TextureType targetPacked,
    444                                       GLsizei levels,
    445                                       GLenum internalformat,
    446                                       GLsizei width,
    447                                       GLsizei height,
    448                                       GLsizei depth);
    449 angle::CallCapture CaptureTexSubImage3D(const State &glState,
    450                                        bool isCallValid,
    451                                        TextureTarget targetPacked,
    452                                        GLint level,
    453                                        GLint xoffset,
    454                                        GLint yoffset,
    455                                        GLint zoffset,
    456                                        GLsizei width,
    457                                        GLsizei height,
    458                                        GLsizei depth,
    459                                        GLenum format,
    460                                        GLenum type,
    461                                        const void *pixels);
    462 angle::CallCapture CaptureTransformFeedbackVaryings(const State &glState,
    463                                                    bool isCallValid,
    464                                                    ShaderProgramID programPacked,
    465                                                    GLsizei count,
    466                                                    const GLchar *const *varyings,
    467                                                    GLenum bufferMode);
    468 angle::CallCapture CaptureUniform1ui(const State &glState,
    469                                     bool isCallValid,
    470                                     UniformLocation locationPacked,
    471                                     GLuint v0);
    472 angle::CallCapture CaptureUniform1uiv(const State &glState,
    473                                      bool isCallValid,
    474                                      UniformLocation locationPacked,
    475                                      GLsizei count,
    476                                      const GLuint *value);
    477 angle::CallCapture CaptureUniform2ui(const State &glState,
    478                                     bool isCallValid,
    479                                     UniformLocation locationPacked,
    480                                     GLuint v0,
    481                                     GLuint v1);
    482 angle::CallCapture CaptureUniform2uiv(const State &glState,
    483                                      bool isCallValid,
    484                                      UniformLocation locationPacked,
    485                                      GLsizei count,
    486                                      const GLuint *value);
    487 angle::CallCapture CaptureUniform3ui(const State &glState,
    488                                     bool isCallValid,
    489                                     UniformLocation locationPacked,
    490                                     GLuint v0,
    491                                     GLuint v1,
    492                                     GLuint v2);
    493 angle::CallCapture CaptureUniform3uiv(const State &glState,
    494                                      bool isCallValid,
    495                                      UniformLocation locationPacked,
    496                                      GLsizei count,
    497                                      const GLuint *value);
    498 angle::CallCapture CaptureUniform4ui(const State &glState,
    499                                     bool isCallValid,
    500                                     UniformLocation locationPacked,
    501                                     GLuint v0,
    502                                     GLuint v1,
    503                                     GLuint v2,
    504                                     GLuint v3);
    505 angle::CallCapture CaptureUniform4uiv(const State &glState,
    506                                      bool isCallValid,
    507                                      UniformLocation locationPacked,
    508                                      GLsizei count,
    509                                      const GLuint *value);
    510 angle::CallCapture CaptureUniformBlockBinding(const State &glState,
    511                                              bool isCallValid,
    512                                              ShaderProgramID programPacked,
    513                                              UniformBlockIndex uniformBlockIndexPacked,
    514                                              GLuint uniformBlockBinding);
    515 angle::CallCapture CaptureUniformMatrix2x3fv(const State &glState,
    516                                             bool isCallValid,
    517                                             UniformLocation locationPacked,
    518                                             GLsizei count,
    519                                             GLboolean transpose,
    520                                             const GLfloat *value);
    521 angle::CallCapture CaptureUniformMatrix2x4fv(const State &glState,
    522                                             bool isCallValid,
    523                                             UniformLocation locationPacked,
    524                                             GLsizei count,
    525                                             GLboolean transpose,
    526                                             const GLfloat *value);
    527 angle::CallCapture CaptureUniformMatrix3x2fv(const State &glState,
    528                                             bool isCallValid,
    529                                             UniformLocation locationPacked,
    530                                             GLsizei count,
    531                                             GLboolean transpose,
    532                                             const GLfloat *value);
    533 angle::CallCapture CaptureUniformMatrix3x4fv(const State &glState,
    534                                             bool isCallValid,
    535                                             UniformLocation locationPacked,
    536                                             GLsizei count,
    537                                             GLboolean transpose,
    538                                             const GLfloat *value);
    539 angle::CallCapture CaptureUniformMatrix4x2fv(const State &glState,
    540                                             bool isCallValid,
    541                                             UniformLocation locationPacked,
    542                                             GLsizei count,
    543                                             GLboolean transpose,
    544                                             const GLfloat *value);
    545 angle::CallCapture CaptureUniformMatrix4x3fv(const State &glState,
    546                                             bool isCallValid,
    547                                             UniformLocation locationPacked,
    548                                             GLsizei count,
    549                                             GLboolean transpose,
    550                                             const GLfloat *value);
    551 angle::CallCapture CaptureUnmapBuffer(const State &glState,
    552                                      bool isCallValid,
    553                                      BufferBinding targetPacked,
    554                                      GLboolean returnValue);
    555 angle::CallCapture CaptureVertexAttribDivisor(const State &glState,
    556                                              bool isCallValid,
    557                                              GLuint index,
    558                                              GLuint divisor);
    559 angle::CallCapture CaptureVertexAttribI4i(const State &glState,
    560                                          bool isCallValid,
    561                                          GLuint index,
    562                                          GLint x,
    563                                          GLint y,
    564                                          GLint z,
    565                                          GLint w);
    566 angle::CallCapture CaptureVertexAttribI4iv(const State &glState,
    567                                           bool isCallValid,
    568                                           GLuint index,
    569                                           const GLint *v);
    570 angle::CallCapture CaptureVertexAttribI4ui(const State &glState,
    571                                           bool isCallValid,
    572                                           GLuint index,
    573                                           GLuint x,
    574                                           GLuint y,
    575                                           GLuint z,
    576                                           GLuint w);
    577 angle::CallCapture CaptureVertexAttribI4uiv(const State &glState,
    578                                            bool isCallValid,
    579                                            GLuint index,
    580                                            const GLuint *v);
    581 angle::CallCapture CaptureVertexAttribIPointer(const State &glState,
    582                                               bool isCallValid,
    583                                               GLuint index,
    584                                               GLint size,
    585                                               VertexAttribType typePacked,
    586                                               GLsizei stride,
    587                                               const void *pointer);
    588 angle::CallCapture CaptureWaitSync(const State &glState,
    589                                   bool isCallValid,
    590                                   GLsync sync,
    591                                   GLbitfield flags,
    592                                   GLuint64 timeout);
    593 
    594 // Parameter Captures
    595 
    596 void CaptureClearBufferfv_value(const State &glState,
    597                                bool isCallValid,
    598                                GLenum buffer,
    599                                GLint drawbuffer,
    600                                const GLfloat *value,
    601                                angle::ParamCapture *paramCapture);
    602 void CaptureClearBufferiv_value(const State &glState,
    603                                bool isCallValid,
    604                                GLenum buffer,
    605                                GLint drawbuffer,
    606                                const GLint *value,
    607                                angle::ParamCapture *paramCapture);
    608 void CaptureClearBufferuiv_value(const State &glState,
    609                                 bool isCallValid,
    610                                 GLenum buffer,
    611                                 GLint drawbuffer,
    612                                 const GLuint *value,
    613                                 angle::ParamCapture *paramCapture);
    614 void CaptureCompressedTexImage3D_data(const State &glState,
    615                                      bool isCallValid,
    616                                      TextureTarget targetPacked,
    617                                      GLint level,
    618                                      GLenum internalformat,
    619                                      GLsizei width,
    620                                      GLsizei height,
    621                                      GLsizei depth,
    622                                      GLint border,
    623                                      GLsizei imageSize,
    624                                      const void *data,
    625                                      angle::ParamCapture *paramCapture);
    626 void CaptureCompressedTexSubImage3D_data(const State &glState,
    627                                         bool isCallValid,
    628                                         TextureTarget targetPacked,
    629                                         GLint level,
    630                                         GLint xoffset,
    631                                         GLint yoffset,
    632                                         GLint zoffset,
    633                                         GLsizei width,
    634                                         GLsizei height,
    635                                         GLsizei depth,
    636                                         GLenum format,
    637                                         GLsizei imageSize,
    638                                         const void *data,
    639                                         angle::ParamCapture *paramCapture);
    640 void CaptureDeleteQueries_idsPacked(const State &glState,
    641                                    bool isCallValid,
    642                                    GLsizei n,
    643                                    const QueryID *idsPacked,
    644                                    angle::ParamCapture *paramCapture);
    645 void CaptureDeleteSamplers_samplersPacked(const State &glState,
    646                                          bool isCallValid,
    647                                          GLsizei count,
    648                                          const SamplerID *samplersPacked,
    649                                          angle::ParamCapture *paramCapture);
    650 void CaptureDeleteTransformFeedbacks_idsPacked(const State &glState,
    651                                               bool isCallValid,
    652                                               GLsizei n,
    653                                               const TransformFeedbackID *idsPacked,
    654                                               angle::ParamCapture *paramCapture);
    655 void CaptureDeleteVertexArrays_arraysPacked(const State &glState,
    656                                            bool isCallValid,
    657                                            GLsizei n,
    658                                            const VertexArrayID *arraysPacked,
    659                                            angle::ParamCapture *paramCapture);
    660 void CaptureDrawBuffers_bufs(const State &glState,
    661                             bool isCallValid,
    662                             GLsizei n,
    663                             const GLenum *bufs,
    664                             angle::ParamCapture *paramCapture);
    665 void CaptureDrawElementsInstanced_indices(const State &glState,
    666                                          bool isCallValid,
    667                                          PrimitiveMode modePacked,
    668                                          GLsizei count,
    669                                          DrawElementsType typePacked,
    670                                          const void *indices,
    671                                          GLsizei instancecount,
    672                                          angle::ParamCapture *paramCapture);
    673 void CaptureDrawRangeElements_indices(const State &glState,
    674                                      bool isCallValid,
    675                                      PrimitiveMode modePacked,
    676                                      GLuint start,
    677                                      GLuint end,
    678                                      GLsizei count,
    679                                      DrawElementsType typePacked,
    680                                      const void *indices,
    681                                      angle::ParamCapture *paramCapture);
    682 void CaptureGenQueries_idsPacked(const State &glState,
    683                                 bool isCallValid,
    684                                 GLsizei n,
    685                                 QueryID *idsPacked,
    686                                 angle::ParamCapture *paramCapture);
    687 void CaptureGenSamplers_samplersPacked(const State &glState,
    688                                       bool isCallValid,
    689                                       GLsizei count,
    690                                       SamplerID *samplersPacked,
    691                                       angle::ParamCapture *paramCapture);
    692 void CaptureGenTransformFeedbacks_idsPacked(const State &glState,
    693                                            bool isCallValid,
    694                                            GLsizei n,
    695                                            TransformFeedbackID *idsPacked,
    696                                            angle::ParamCapture *paramCapture);
    697 void CaptureGenVertexArrays_arraysPacked(const State &glState,
    698                                         bool isCallValid,
    699                                         GLsizei n,
    700                                         VertexArrayID *arraysPacked,
    701                                         angle::ParamCapture *paramCapture);
    702 void CaptureGetActiveUniformBlockName_length(const State &glState,
    703                                             bool isCallValid,
    704                                             ShaderProgramID programPacked,
    705                                             UniformBlockIndex uniformBlockIndexPacked,
    706                                             GLsizei bufSize,
    707                                             GLsizei *length,
    708                                             GLchar *uniformBlockName,
    709                                             angle::ParamCapture *paramCapture);
    710 void CaptureGetActiveUniformBlockName_uniformBlockName(const State &glState,
    711                                                       bool isCallValid,
    712                                                       ShaderProgramID programPacked,
    713                                                       UniformBlockIndex uniformBlockIndexPacked,
    714                                                       GLsizei bufSize,
    715                                                       GLsizei *length,
    716                                                       GLchar *uniformBlockName,
    717                                                       angle::ParamCapture *paramCapture);
    718 void CaptureGetActiveUniformBlockiv_params(const State &glState,
    719                                           bool isCallValid,
    720                                           ShaderProgramID programPacked,
    721                                           UniformBlockIndex uniformBlockIndexPacked,
    722                                           GLenum pname,
    723                                           GLint *params,
    724                                           angle::ParamCapture *paramCapture);
    725 void CaptureGetActiveUniformsiv_uniformIndices(const State &glState,
    726                                               bool isCallValid,
    727                                               ShaderProgramID programPacked,
    728                                               GLsizei uniformCount,
    729                                               const GLuint *uniformIndices,
    730                                               GLenum pname,
    731                                               GLint *params,
    732                                               angle::ParamCapture *paramCapture);
    733 void CaptureGetActiveUniformsiv_params(const State &glState,
    734                                       bool isCallValid,
    735                                       ShaderProgramID programPacked,
    736                                       GLsizei uniformCount,
    737                                       const GLuint *uniformIndices,
    738                                       GLenum pname,
    739                                       GLint *params,
    740                                       angle::ParamCapture *paramCapture);
    741 void CaptureGetBufferParameteri64v_params(const State &glState,
    742                                          bool isCallValid,
    743                                          BufferBinding targetPacked,
    744                                          GLenum pname,
    745                                          GLint64 *params,
    746                                          angle::ParamCapture *paramCapture);
    747 void CaptureGetBufferPointerv_params(const State &glState,
    748                                     bool isCallValid,
    749                                     BufferBinding targetPacked,
    750                                     GLenum pname,
    751                                     void **params,
    752                                     angle::ParamCapture *paramCapture);
    753 void CaptureGetFragDataLocation_name(const State &glState,
    754                                     bool isCallValid,
    755                                     ShaderProgramID programPacked,
    756                                     const GLchar *name,
    757                                     angle::ParamCapture *paramCapture);
    758 void CaptureGetInteger64i_v_data(const State &glState,
    759                                 bool isCallValid,
    760                                 GLenum target,
    761                                 GLuint index,
    762                                 GLint64 *data,
    763                                 angle::ParamCapture *paramCapture);
    764 void CaptureGetInteger64v_data(const State &glState,
    765                               bool isCallValid,
    766                               GLenum pname,
    767                               GLint64 *data,
    768                               angle::ParamCapture *paramCapture);
    769 void CaptureGetIntegeri_v_data(const State &glState,
    770                               bool isCallValid,
    771                               GLenum target,
    772                               GLuint index,
    773                               GLint *data,
    774                               angle::ParamCapture *paramCapture);
    775 void CaptureGetInternalformativ_params(const State &glState,
    776                                       bool isCallValid,
    777                                       GLenum target,
    778                                       GLenum internalformat,
    779                                       GLenum pname,
    780                                       GLsizei count,
    781                                       GLint *params,
    782                                       angle::ParamCapture *paramCapture);
    783 void CaptureGetProgramBinary_length(const State &glState,
    784                                    bool isCallValid,
    785                                    ShaderProgramID programPacked,
    786                                    GLsizei bufSize,
    787                                    GLsizei *length,
    788                                    GLenum *binaryFormat,
    789                                    void *binary,
    790                                    angle::ParamCapture *paramCapture);
    791 void CaptureGetProgramBinary_binaryFormat(const State &glState,
    792                                          bool isCallValid,
    793                                          ShaderProgramID programPacked,
    794                                          GLsizei bufSize,
    795                                          GLsizei *length,
    796                                          GLenum *binaryFormat,
    797                                          void *binary,
    798                                          angle::ParamCapture *paramCapture);
    799 void CaptureGetProgramBinary_binary(const State &glState,
    800                                    bool isCallValid,
    801                                    ShaderProgramID programPacked,
    802                                    GLsizei bufSize,
    803                                    GLsizei *length,
    804                                    GLenum *binaryFormat,
    805                                    void *binary,
    806                                    angle::ParamCapture *paramCapture);
    807 void CaptureGetQueryObjectuiv_params(const State &glState,
    808                                     bool isCallValid,
    809                                     QueryID idPacked,
    810                                     GLenum pname,
    811                                     GLuint *params,
    812                                     angle::ParamCapture *paramCapture);
    813 void CaptureGetQueryiv_params(const State &glState,
    814                              bool isCallValid,
    815                              QueryType targetPacked,
    816                              GLenum pname,
    817                              GLint *params,
    818                              angle::ParamCapture *paramCapture);
    819 void CaptureGetSamplerParameterfv_params(const State &glState,
    820                                         bool isCallValid,
    821                                         SamplerID samplerPacked,
    822                                         GLenum pname,
    823                                         GLfloat *params,
    824                                         angle::ParamCapture *paramCapture);
    825 void CaptureGetSamplerParameteriv_params(const State &glState,
    826                                         bool isCallValid,
    827                                         SamplerID samplerPacked,
    828                                         GLenum pname,
    829                                         GLint *params,
    830                                         angle::ParamCapture *paramCapture);
    831 void CaptureGetSynciv_length(const State &glState,
    832                             bool isCallValid,
    833                             GLsync sync,
    834                             GLenum pname,
    835                             GLsizei count,
    836                             GLsizei *length,
    837                             GLint *values,
    838                             angle::ParamCapture *paramCapture);
    839 void CaptureGetSynciv_values(const State &glState,
    840                             bool isCallValid,
    841                             GLsync sync,
    842                             GLenum pname,
    843                             GLsizei count,
    844                             GLsizei *length,
    845                             GLint *values,
    846                             angle::ParamCapture *paramCapture);
    847 void CaptureGetTransformFeedbackVarying_length(const State &glState,
    848                                               bool isCallValid,
    849                                               ShaderProgramID programPacked,
    850                                               GLuint index,
    851                                               GLsizei bufSize,
    852                                               GLsizei *length,
    853                                               GLsizei *size,
    854                                               GLenum *type,
    855                                               GLchar *name,
    856                                               angle::ParamCapture *paramCapture);
    857 void CaptureGetTransformFeedbackVarying_size(const State &glState,
    858                                             bool isCallValid,
    859                                             ShaderProgramID programPacked,
    860                                             GLuint index,
    861                                             GLsizei bufSize,
    862                                             GLsizei *length,
    863                                             GLsizei *size,
    864                                             GLenum *type,
    865                                             GLchar *name,
    866                                             angle::ParamCapture *paramCapture);
    867 void CaptureGetTransformFeedbackVarying_type(const State &glState,
    868                                             bool isCallValid,
    869                                             ShaderProgramID programPacked,
    870                                             GLuint index,
    871                                             GLsizei bufSize,
    872                                             GLsizei *length,
    873                                             GLsizei *size,
    874                                             GLenum *type,
    875                                             GLchar *name,
    876                                             angle::ParamCapture *paramCapture);
    877 void CaptureGetTransformFeedbackVarying_name(const State &glState,
    878                                             bool isCallValid,
    879                                             ShaderProgramID programPacked,
    880                                             GLuint index,
    881                                             GLsizei bufSize,
    882                                             GLsizei *length,
    883                                             GLsizei *size,
    884                                             GLenum *type,
    885                                             GLchar *name,
    886                                             angle::ParamCapture *paramCapture);
    887 void CaptureGetUniformBlockIndex_uniformBlockName(const State &glState,
    888                                                  bool isCallValid,
    889                                                  ShaderProgramID programPacked,
    890                                                  const GLchar *uniformBlockName,
    891                                                  angle::ParamCapture *paramCapture);
    892 void CaptureGetUniformIndices_uniformNames(const State &glState,
    893                                           bool isCallValid,
    894                                           ShaderProgramID programPacked,
    895                                           GLsizei uniformCount,
    896                                           const GLchar *const *uniformNames,
    897                                           GLuint *uniformIndices,
    898                                           angle::ParamCapture *paramCapture);
    899 void CaptureGetUniformIndices_uniformIndices(const State &glState,
    900                                             bool isCallValid,
    901                                             ShaderProgramID programPacked,
    902                                             GLsizei uniformCount,
    903                                             const GLchar *const *uniformNames,
    904                                             GLuint *uniformIndices,
    905                                             angle::ParamCapture *paramCapture);
    906 void CaptureGetUniformuiv_params(const State &glState,
    907                                 bool isCallValid,
    908                                 ShaderProgramID programPacked,
    909                                 UniformLocation locationPacked,
    910                                 GLuint *params,
    911                                 angle::ParamCapture *paramCapture);
    912 void CaptureGetVertexAttribIiv_params(const State &glState,
    913                                      bool isCallValid,
    914                                      GLuint index,
    915                                      GLenum pname,
    916                                      GLint *params,
    917                                      angle::ParamCapture *paramCapture);
    918 void CaptureGetVertexAttribIuiv_params(const State &glState,
    919                                       bool isCallValid,
    920                                       GLuint index,
    921                                       GLenum pname,
    922                                       GLuint *params,
    923                                       angle::ParamCapture *paramCapture);
    924 void CaptureInvalidateFramebuffer_attachments(const State &glState,
    925                                              bool isCallValid,
    926                                              GLenum target,
    927                                              GLsizei numAttachments,
    928                                              const GLenum *attachments,
    929                                              angle::ParamCapture *paramCapture);
    930 void CaptureInvalidateSubFramebuffer_attachments(const State &glState,
    931                                                 bool isCallValid,
    932                                                 GLenum target,
    933                                                 GLsizei numAttachments,
    934                                                 const GLenum *attachments,
    935                                                 GLint x,
    936                                                 GLint y,
    937                                                 GLsizei width,
    938                                                 GLsizei height,
    939                                                 angle::ParamCapture *paramCapture);
    940 void CaptureProgramBinary_binary(const State &glState,
    941                                 bool isCallValid,
    942                                 ShaderProgramID programPacked,
    943                                 GLenum binaryFormat,
    944                                 const void *binary,
    945                                 GLsizei length,
    946                                 angle::ParamCapture *paramCapture);
    947 void CaptureSamplerParameterfv_param(const State &glState,
    948                                     bool isCallValid,
    949                                     SamplerID samplerPacked,
    950                                     GLenum pname,
    951                                     const GLfloat *param,
    952                                     angle::ParamCapture *paramCapture);
    953 void CaptureSamplerParameteriv_param(const State &glState,
    954                                     bool isCallValid,
    955                                     SamplerID samplerPacked,
    956                                     GLenum pname,
    957                                     const GLint *param,
    958                                     angle::ParamCapture *paramCapture);
    959 void CaptureTexImage3D_pixels(const State &glState,
    960                              bool isCallValid,
    961                              TextureTarget targetPacked,
    962                              GLint level,
    963                              GLint internalformat,
    964                              GLsizei width,
    965                              GLsizei height,
    966                              GLsizei depth,
    967                              GLint border,
    968                              GLenum format,
    969                              GLenum type,
    970                              const void *pixels,
    971                              angle::ParamCapture *paramCapture);
    972 void CaptureTexSubImage3D_pixels(const State &glState,
    973                                 bool isCallValid,
    974                                 TextureTarget targetPacked,
    975                                 GLint level,
    976                                 GLint xoffset,
    977                                 GLint yoffset,
    978                                 GLint zoffset,
    979                                 GLsizei width,
    980                                 GLsizei height,
    981                                 GLsizei depth,
    982                                 GLenum format,
    983                                 GLenum type,
    984                                 const void *pixels,
    985                                 angle::ParamCapture *paramCapture);
    986 void CaptureTransformFeedbackVaryings_varyings(const State &glState,
    987                                               bool isCallValid,
    988                                               ShaderProgramID programPacked,
    989                                               GLsizei count,
    990                                               const GLchar *const *varyings,
    991                                               GLenum bufferMode,
    992                                               angle::ParamCapture *paramCapture);
    993 void CaptureUniform1uiv_value(const State &glState,
    994                              bool isCallValid,
    995                              UniformLocation locationPacked,
    996                              GLsizei count,
    997                              const GLuint *value,
    998                              angle::ParamCapture *paramCapture);
    999 void CaptureUniform2uiv_value(const State &glState,
   1000                              bool isCallValid,
   1001                              UniformLocation locationPacked,
   1002                              GLsizei count,
   1003                              const GLuint *value,
   1004                              angle::ParamCapture *paramCapture);
   1005 void CaptureUniform3uiv_value(const State &glState,
   1006                              bool isCallValid,
   1007                              UniformLocation locationPacked,
   1008                              GLsizei count,
   1009                              const GLuint *value,
   1010                              angle::ParamCapture *paramCapture);
   1011 void CaptureUniform4uiv_value(const State &glState,
   1012                              bool isCallValid,
   1013                              UniformLocation locationPacked,
   1014                              GLsizei count,
   1015                              const GLuint *value,
   1016                              angle::ParamCapture *paramCapture);
   1017 void CaptureUniformMatrix2x3fv_value(const State &glState,
   1018                                     bool isCallValid,
   1019                                     UniformLocation locationPacked,
   1020                                     GLsizei count,
   1021                                     GLboolean transpose,
   1022                                     const GLfloat *value,
   1023                                     angle::ParamCapture *paramCapture);
   1024 void CaptureUniformMatrix2x4fv_value(const State &glState,
   1025                                     bool isCallValid,
   1026                                     UniformLocation locationPacked,
   1027                                     GLsizei count,
   1028                                     GLboolean transpose,
   1029                                     const GLfloat *value,
   1030                                     angle::ParamCapture *paramCapture);
   1031 void CaptureUniformMatrix3x2fv_value(const State &glState,
   1032                                     bool isCallValid,
   1033                                     UniformLocation locationPacked,
   1034                                     GLsizei count,
   1035                                     GLboolean transpose,
   1036                                     const GLfloat *value,
   1037                                     angle::ParamCapture *paramCapture);
   1038 void CaptureUniformMatrix3x4fv_value(const State &glState,
   1039                                     bool isCallValid,
   1040                                     UniformLocation locationPacked,
   1041                                     GLsizei count,
   1042                                     GLboolean transpose,
   1043                                     const GLfloat *value,
   1044                                     angle::ParamCapture *paramCapture);
   1045 void CaptureUniformMatrix4x2fv_value(const State &glState,
   1046                                     bool isCallValid,
   1047                                     UniformLocation locationPacked,
   1048                                     GLsizei count,
   1049                                     GLboolean transpose,
   1050                                     const GLfloat *value,
   1051                                     angle::ParamCapture *paramCapture);
   1052 void CaptureUniformMatrix4x3fv_value(const State &glState,
   1053                                     bool isCallValid,
   1054                                     UniformLocation locationPacked,
   1055                                     GLsizei count,
   1056                                     GLboolean transpose,
   1057                                     const GLfloat *value,
   1058                                     angle::ParamCapture *paramCapture);
   1059 void CaptureVertexAttribI4iv_v(const State &glState,
   1060                               bool isCallValid,
   1061                               GLuint index,
   1062                               const GLint *v,
   1063                               angle::ParamCapture *paramCapture);
   1064 void CaptureVertexAttribI4uiv_v(const State &glState,
   1065                                bool isCallValid,
   1066                                GLuint index,
   1067                                const GLuint *v,
   1068                                angle::ParamCapture *paramCapture);
   1069 void CaptureVertexAttribIPointer_pointer(const State &glState,
   1070                                         bool isCallValid,
   1071                                         GLuint index,
   1072                                         GLint size,
   1073                                         VertexAttribType typePacked,
   1074                                         GLsizei stride,
   1075                                         const void *pointer,
   1076                                         angle::ParamCapture *paramCapture);
   1077 }  // namespace gl
   1078 
   1079 #endif  // LIBANGLE_CAPTURE_GLES_3_0_AUTOGEN_H_