tor-browser

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

capture_gles_3_1_autogen.h (47070B)


      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_1_autogen.h:
      9 //   Capture functions for the OpenGL ES 3.1 entry points.
     10 
     11 #ifndef LIBANGLE_CAPTURE_GLES_3_1_AUTOGEN_H_
     12 #define LIBANGLE_CAPTURE_GLES_3_1_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 CaptureActiveShaderProgram(const State &glState,
     23                                              bool isCallValid,
     24                                              ProgramPipelineID pipelinePacked,
     25                                              ShaderProgramID programPacked);
     26 angle::CallCapture CaptureBindImageTexture(const State &glState,
     27                                           bool isCallValid,
     28                                           GLuint unit,
     29                                           TextureID texturePacked,
     30                                           GLint level,
     31                                           GLboolean layered,
     32                                           GLint layer,
     33                                           GLenum access,
     34                                           GLenum format);
     35 angle::CallCapture CaptureBindProgramPipeline(const State &glState,
     36                                              bool isCallValid,
     37                                              ProgramPipelineID pipelinePacked);
     38 angle::CallCapture CaptureBindVertexBuffer(const State &glState,
     39                                           bool isCallValid,
     40                                           GLuint bindingindex,
     41                                           BufferID bufferPacked,
     42                                           GLintptr offset,
     43                                           GLsizei stride);
     44 angle::CallCapture CaptureCreateShaderProgramv(const State &glState,
     45                                               bool isCallValid,
     46                                               ShaderType typePacked,
     47                                               GLsizei count,
     48                                               const GLchar *const *strings,
     49                                               GLuint returnValue);
     50 angle::CallCapture CaptureDeleteProgramPipelines(const State &glState,
     51                                                 bool isCallValid,
     52                                                 GLsizei n,
     53                                                 const ProgramPipelineID *pipelinesPacked);
     54 angle::CallCapture CaptureDispatchCompute(const State &glState,
     55                                          bool isCallValid,
     56                                          GLuint num_groups_x,
     57                                          GLuint num_groups_y,
     58                                          GLuint num_groups_z);
     59 angle::CallCapture CaptureDispatchComputeIndirect(const State &glState,
     60                                                  bool isCallValid,
     61                                                  GLintptr indirect);
     62 angle::CallCapture CaptureDrawArraysIndirect(const State &glState,
     63                                             bool isCallValid,
     64                                             PrimitiveMode modePacked,
     65                                             const void *indirect);
     66 angle::CallCapture CaptureDrawElementsIndirect(const State &glState,
     67                                               bool isCallValid,
     68                                               PrimitiveMode modePacked,
     69                                               DrawElementsType typePacked,
     70                                               const void *indirect);
     71 angle::CallCapture CaptureFramebufferParameteri(const State &glState,
     72                                                bool isCallValid,
     73                                                GLenum target,
     74                                                GLenum pname,
     75                                                GLint param);
     76 angle::CallCapture CaptureGenProgramPipelines(const State &glState,
     77                                              bool isCallValid,
     78                                              GLsizei n,
     79                                              ProgramPipelineID *pipelinesPacked);
     80 angle::CallCapture CaptureGetBooleani_v(const State &glState,
     81                                        bool isCallValid,
     82                                        GLenum target,
     83                                        GLuint index,
     84                                        GLboolean *data);
     85 angle::CallCapture CaptureGetFramebufferParameteriv(const State &glState,
     86                                                    bool isCallValid,
     87                                                    GLenum target,
     88                                                    GLenum pname,
     89                                                    GLint *params);
     90 angle::CallCapture CaptureGetMultisamplefv(const State &glState,
     91                                           bool isCallValid,
     92                                           GLenum pname,
     93                                           GLuint index,
     94                                           GLfloat *val);
     95 angle::CallCapture CaptureGetProgramInterfaceiv(const State &glState,
     96                                                bool isCallValid,
     97                                                ShaderProgramID programPacked,
     98                                                GLenum programInterface,
     99                                                GLenum pname,
    100                                                GLint *params);
    101 angle::CallCapture CaptureGetProgramPipelineInfoLog(const State &glState,
    102                                                    bool isCallValid,
    103                                                    ProgramPipelineID pipelinePacked,
    104                                                    GLsizei bufSize,
    105                                                    GLsizei *length,
    106                                                    GLchar *infoLog);
    107 angle::CallCapture CaptureGetProgramPipelineiv(const State &glState,
    108                                               bool isCallValid,
    109                                               ProgramPipelineID pipelinePacked,
    110                                               GLenum pname,
    111                                               GLint *params);
    112 angle::CallCapture CaptureGetProgramResourceIndex(const State &glState,
    113                                                  bool isCallValid,
    114                                                  ShaderProgramID programPacked,
    115                                                  GLenum programInterface,
    116                                                  const GLchar *name,
    117                                                  GLuint returnValue);
    118 angle::CallCapture CaptureGetProgramResourceLocation(const State &glState,
    119                                                     bool isCallValid,
    120                                                     ShaderProgramID programPacked,
    121                                                     GLenum programInterface,
    122                                                     const GLchar *name,
    123                                                     GLint returnValue);
    124 angle::CallCapture CaptureGetProgramResourceName(const State &glState,
    125                                                 bool isCallValid,
    126                                                 ShaderProgramID programPacked,
    127                                                 GLenum programInterface,
    128                                                 GLuint index,
    129                                                 GLsizei bufSize,
    130                                                 GLsizei *length,
    131                                                 GLchar *name);
    132 angle::CallCapture CaptureGetProgramResourceiv(const State &glState,
    133                                               bool isCallValid,
    134                                               ShaderProgramID programPacked,
    135                                               GLenum programInterface,
    136                                               GLuint index,
    137                                               GLsizei propCount,
    138                                               const GLenum *props,
    139                                               GLsizei count,
    140                                               GLsizei *length,
    141                                               GLint *params);
    142 angle::CallCapture CaptureGetTexLevelParameterfv(const State &glState,
    143                                                 bool isCallValid,
    144                                                 TextureTarget targetPacked,
    145                                                 GLint level,
    146                                                 GLenum pname,
    147                                                 GLfloat *params);
    148 angle::CallCapture CaptureGetTexLevelParameteriv(const State &glState,
    149                                                 bool isCallValid,
    150                                                 TextureTarget targetPacked,
    151                                                 GLint level,
    152                                                 GLenum pname,
    153                                                 GLint *params);
    154 angle::CallCapture CaptureIsProgramPipeline(const State &glState,
    155                                            bool isCallValid,
    156                                            ProgramPipelineID pipelinePacked,
    157                                            GLboolean returnValue);
    158 angle::CallCapture CaptureMemoryBarrier(const State &glState,
    159                                        bool isCallValid,
    160                                        GLbitfield barriers);
    161 angle::CallCapture CaptureMemoryBarrierByRegion(const State &glState,
    162                                                bool isCallValid,
    163                                                GLbitfield barriers);
    164 angle::CallCapture CaptureProgramUniform1f(const State &glState,
    165                                           bool isCallValid,
    166                                           ShaderProgramID programPacked,
    167                                           UniformLocation locationPacked,
    168                                           GLfloat v0);
    169 angle::CallCapture CaptureProgramUniform1fv(const State &glState,
    170                                            bool isCallValid,
    171                                            ShaderProgramID programPacked,
    172                                            UniformLocation locationPacked,
    173                                            GLsizei count,
    174                                            const GLfloat *value);
    175 angle::CallCapture CaptureProgramUniform1i(const State &glState,
    176                                           bool isCallValid,
    177                                           ShaderProgramID programPacked,
    178                                           UniformLocation locationPacked,
    179                                           GLint v0);
    180 angle::CallCapture CaptureProgramUniform1iv(const State &glState,
    181                                            bool isCallValid,
    182                                            ShaderProgramID programPacked,
    183                                            UniformLocation locationPacked,
    184                                            GLsizei count,
    185                                            const GLint *value);
    186 angle::CallCapture CaptureProgramUniform1ui(const State &glState,
    187                                            bool isCallValid,
    188                                            ShaderProgramID programPacked,
    189                                            UniformLocation locationPacked,
    190                                            GLuint v0);
    191 angle::CallCapture CaptureProgramUniform1uiv(const State &glState,
    192                                             bool isCallValid,
    193                                             ShaderProgramID programPacked,
    194                                             UniformLocation locationPacked,
    195                                             GLsizei count,
    196                                             const GLuint *value);
    197 angle::CallCapture CaptureProgramUniform2f(const State &glState,
    198                                           bool isCallValid,
    199                                           ShaderProgramID programPacked,
    200                                           UniformLocation locationPacked,
    201                                           GLfloat v0,
    202                                           GLfloat v1);
    203 angle::CallCapture CaptureProgramUniform2fv(const State &glState,
    204                                            bool isCallValid,
    205                                            ShaderProgramID programPacked,
    206                                            UniformLocation locationPacked,
    207                                            GLsizei count,
    208                                            const GLfloat *value);
    209 angle::CallCapture CaptureProgramUniform2i(const State &glState,
    210                                           bool isCallValid,
    211                                           ShaderProgramID programPacked,
    212                                           UniformLocation locationPacked,
    213                                           GLint v0,
    214                                           GLint v1);
    215 angle::CallCapture CaptureProgramUniform2iv(const State &glState,
    216                                            bool isCallValid,
    217                                            ShaderProgramID programPacked,
    218                                            UniformLocation locationPacked,
    219                                            GLsizei count,
    220                                            const GLint *value);
    221 angle::CallCapture CaptureProgramUniform2ui(const State &glState,
    222                                            bool isCallValid,
    223                                            ShaderProgramID programPacked,
    224                                            UniformLocation locationPacked,
    225                                            GLuint v0,
    226                                            GLuint v1);
    227 angle::CallCapture CaptureProgramUniform2uiv(const State &glState,
    228                                             bool isCallValid,
    229                                             ShaderProgramID programPacked,
    230                                             UniformLocation locationPacked,
    231                                             GLsizei count,
    232                                             const GLuint *value);
    233 angle::CallCapture CaptureProgramUniform3f(const State &glState,
    234                                           bool isCallValid,
    235                                           ShaderProgramID programPacked,
    236                                           UniformLocation locationPacked,
    237                                           GLfloat v0,
    238                                           GLfloat v1,
    239                                           GLfloat v2);
    240 angle::CallCapture CaptureProgramUniform3fv(const State &glState,
    241                                            bool isCallValid,
    242                                            ShaderProgramID programPacked,
    243                                            UniformLocation locationPacked,
    244                                            GLsizei count,
    245                                            const GLfloat *value);
    246 angle::CallCapture CaptureProgramUniform3i(const State &glState,
    247                                           bool isCallValid,
    248                                           ShaderProgramID programPacked,
    249                                           UniformLocation locationPacked,
    250                                           GLint v0,
    251                                           GLint v1,
    252                                           GLint v2);
    253 angle::CallCapture CaptureProgramUniform3iv(const State &glState,
    254                                            bool isCallValid,
    255                                            ShaderProgramID programPacked,
    256                                            UniformLocation locationPacked,
    257                                            GLsizei count,
    258                                            const GLint *value);
    259 angle::CallCapture CaptureProgramUniform3ui(const State &glState,
    260                                            bool isCallValid,
    261                                            ShaderProgramID programPacked,
    262                                            UniformLocation locationPacked,
    263                                            GLuint v0,
    264                                            GLuint v1,
    265                                            GLuint v2);
    266 angle::CallCapture CaptureProgramUniform3uiv(const State &glState,
    267                                             bool isCallValid,
    268                                             ShaderProgramID programPacked,
    269                                             UniformLocation locationPacked,
    270                                             GLsizei count,
    271                                             const GLuint *value);
    272 angle::CallCapture CaptureProgramUniform4f(const State &glState,
    273                                           bool isCallValid,
    274                                           ShaderProgramID programPacked,
    275                                           UniformLocation locationPacked,
    276                                           GLfloat v0,
    277                                           GLfloat v1,
    278                                           GLfloat v2,
    279                                           GLfloat v3);
    280 angle::CallCapture CaptureProgramUniform4fv(const State &glState,
    281                                            bool isCallValid,
    282                                            ShaderProgramID programPacked,
    283                                            UniformLocation locationPacked,
    284                                            GLsizei count,
    285                                            const GLfloat *value);
    286 angle::CallCapture CaptureProgramUniform4i(const State &glState,
    287                                           bool isCallValid,
    288                                           ShaderProgramID programPacked,
    289                                           UniformLocation locationPacked,
    290                                           GLint v0,
    291                                           GLint v1,
    292                                           GLint v2,
    293                                           GLint v3);
    294 angle::CallCapture CaptureProgramUniform4iv(const State &glState,
    295                                            bool isCallValid,
    296                                            ShaderProgramID programPacked,
    297                                            UniformLocation locationPacked,
    298                                            GLsizei count,
    299                                            const GLint *value);
    300 angle::CallCapture CaptureProgramUniform4ui(const State &glState,
    301                                            bool isCallValid,
    302                                            ShaderProgramID programPacked,
    303                                            UniformLocation locationPacked,
    304                                            GLuint v0,
    305                                            GLuint v1,
    306                                            GLuint v2,
    307                                            GLuint v3);
    308 angle::CallCapture CaptureProgramUniform4uiv(const State &glState,
    309                                             bool isCallValid,
    310                                             ShaderProgramID programPacked,
    311                                             UniformLocation locationPacked,
    312                                             GLsizei count,
    313                                             const GLuint *value);
    314 angle::CallCapture CaptureProgramUniformMatrix2fv(const State &glState,
    315                                                  bool isCallValid,
    316                                                  ShaderProgramID programPacked,
    317                                                  UniformLocation locationPacked,
    318                                                  GLsizei count,
    319                                                  GLboolean transpose,
    320                                                  const GLfloat *value);
    321 angle::CallCapture CaptureProgramUniformMatrix2x3fv(const State &glState,
    322                                                    bool isCallValid,
    323                                                    ShaderProgramID programPacked,
    324                                                    UniformLocation locationPacked,
    325                                                    GLsizei count,
    326                                                    GLboolean transpose,
    327                                                    const GLfloat *value);
    328 angle::CallCapture CaptureProgramUniformMatrix2x4fv(const State &glState,
    329                                                    bool isCallValid,
    330                                                    ShaderProgramID programPacked,
    331                                                    UniformLocation locationPacked,
    332                                                    GLsizei count,
    333                                                    GLboolean transpose,
    334                                                    const GLfloat *value);
    335 angle::CallCapture CaptureProgramUniformMatrix3fv(const State &glState,
    336                                                  bool isCallValid,
    337                                                  ShaderProgramID programPacked,
    338                                                  UniformLocation locationPacked,
    339                                                  GLsizei count,
    340                                                  GLboolean transpose,
    341                                                  const GLfloat *value);
    342 angle::CallCapture CaptureProgramUniformMatrix3x2fv(const State &glState,
    343                                                    bool isCallValid,
    344                                                    ShaderProgramID programPacked,
    345                                                    UniformLocation locationPacked,
    346                                                    GLsizei count,
    347                                                    GLboolean transpose,
    348                                                    const GLfloat *value);
    349 angle::CallCapture CaptureProgramUniformMatrix3x4fv(const State &glState,
    350                                                    bool isCallValid,
    351                                                    ShaderProgramID programPacked,
    352                                                    UniformLocation locationPacked,
    353                                                    GLsizei count,
    354                                                    GLboolean transpose,
    355                                                    const GLfloat *value);
    356 angle::CallCapture CaptureProgramUniformMatrix4fv(const State &glState,
    357                                                  bool isCallValid,
    358                                                  ShaderProgramID programPacked,
    359                                                  UniformLocation locationPacked,
    360                                                  GLsizei count,
    361                                                  GLboolean transpose,
    362                                                  const GLfloat *value);
    363 angle::CallCapture CaptureProgramUniformMatrix4x2fv(const State &glState,
    364                                                    bool isCallValid,
    365                                                    ShaderProgramID programPacked,
    366                                                    UniformLocation locationPacked,
    367                                                    GLsizei count,
    368                                                    GLboolean transpose,
    369                                                    const GLfloat *value);
    370 angle::CallCapture CaptureProgramUniformMatrix4x3fv(const State &glState,
    371                                                    bool isCallValid,
    372                                                    ShaderProgramID programPacked,
    373                                                    UniformLocation locationPacked,
    374                                                    GLsizei count,
    375                                                    GLboolean transpose,
    376                                                    const GLfloat *value);
    377 angle::CallCapture CaptureSampleMaski(const State &glState,
    378                                      bool isCallValid,
    379                                      GLuint maskNumber,
    380                                      GLbitfield mask);
    381 angle::CallCapture CaptureTexStorage2DMultisample(const State &glState,
    382                                                  bool isCallValid,
    383                                                  TextureType targetPacked,
    384                                                  GLsizei samples,
    385                                                  GLenum internalformat,
    386                                                  GLsizei width,
    387                                                  GLsizei height,
    388                                                  GLboolean fixedsamplelocations);
    389 angle::CallCapture CaptureUseProgramStages(const State &glState,
    390                                           bool isCallValid,
    391                                           ProgramPipelineID pipelinePacked,
    392                                           GLbitfield stages,
    393                                           ShaderProgramID programPacked);
    394 angle::CallCapture CaptureValidateProgramPipeline(const State &glState,
    395                                                  bool isCallValid,
    396                                                  ProgramPipelineID pipelinePacked);
    397 angle::CallCapture CaptureVertexAttribBinding(const State &glState,
    398                                              bool isCallValid,
    399                                              GLuint attribindex,
    400                                              GLuint bindingindex);
    401 angle::CallCapture CaptureVertexAttribFormat(const State &glState,
    402                                             bool isCallValid,
    403                                             GLuint attribindex,
    404                                             GLint size,
    405                                             VertexAttribType typePacked,
    406                                             GLboolean normalized,
    407                                             GLuint relativeoffset);
    408 angle::CallCapture CaptureVertexAttribIFormat(const State &glState,
    409                                              bool isCallValid,
    410                                              GLuint attribindex,
    411                                              GLint size,
    412                                              VertexAttribType typePacked,
    413                                              GLuint relativeoffset);
    414 angle::CallCapture CaptureVertexBindingDivisor(const State &glState,
    415                                               bool isCallValid,
    416                                               GLuint bindingindex,
    417                                               GLuint divisor);
    418 
    419 // Parameter Captures
    420 
    421 void CaptureCreateShaderProgramv_strings(const State &glState,
    422                                         bool isCallValid,
    423                                         ShaderType typePacked,
    424                                         GLsizei count,
    425                                         const GLchar *const *strings,
    426                                         angle::ParamCapture *paramCapture);
    427 void CaptureDeleteProgramPipelines_pipelinesPacked(const State &glState,
    428                                                   bool isCallValid,
    429                                                   GLsizei n,
    430                                                   const ProgramPipelineID *pipelinesPacked,
    431                                                   angle::ParamCapture *paramCapture);
    432 void CaptureDrawArraysIndirect_indirect(const State &glState,
    433                                        bool isCallValid,
    434                                        PrimitiveMode modePacked,
    435                                        const void *indirect,
    436                                        angle::ParamCapture *paramCapture);
    437 void CaptureDrawElementsIndirect_indirect(const State &glState,
    438                                          bool isCallValid,
    439                                          PrimitiveMode modePacked,
    440                                          DrawElementsType typePacked,
    441                                          const void *indirect,
    442                                          angle::ParamCapture *paramCapture);
    443 void CaptureGenProgramPipelines_pipelinesPacked(const State &glState,
    444                                                bool isCallValid,
    445                                                GLsizei n,
    446                                                ProgramPipelineID *pipelinesPacked,
    447                                                angle::ParamCapture *paramCapture);
    448 void CaptureGetBooleani_v_data(const State &glState,
    449                               bool isCallValid,
    450                               GLenum target,
    451                               GLuint index,
    452                               GLboolean *data,
    453                               angle::ParamCapture *paramCapture);
    454 void CaptureGetFramebufferParameteriv_params(const State &glState,
    455                                             bool isCallValid,
    456                                             GLenum target,
    457                                             GLenum pname,
    458                                             GLint *params,
    459                                             angle::ParamCapture *paramCapture);
    460 void CaptureGetMultisamplefv_val(const State &glState,
    461                                 bool isCallValid,
    462                                 GLenum pname,
    463                                 GLuint index,
    464                                 GLfloat *val,
    465                                 angle::ParamCapture *paramCapture);
    466 void CaptureGetProgramInterfaceiv_params(const State &glState,
    467                                         bool isCallValid,
    468                                         ShaderProgramID programPacked,
    469                                         GLenum programInterface,
    470                                         GLenum pname,
    471                                         GLint *params,
    472                                         angle::ParamCapture *paramCapture);
    473 void CaptureGetProgramPipelineInfoLog_length(const State &glState,
    474                                             bool isCallValid,
    475                                             ProgramPipelineID pipelinePacked,
    476                                             GLsizei bufSize,
    477                                             GLsizei *length,
    478                                             GLchar *infoLog,
    479                                             angle::ParamCapture *paramCapture);
    480 void CaptureGetProgramPipelineInfoLog_infoLog(const State &glState,
    481                                              bool isCallValid,
    482                                              ProgramPipelineID pipelinePacked,
    483                                              GLsizei bufSize,
    484                                              GLsizei *length,
    485                                              GLchar *infoLog,
    486                                              angle::ParamCapture *paramCapture);
    487 void CaptureGetProgramPipelineiv_params(const State &glState,
    488                                        bool isCallValid,
    489                                        ProgramPipelineID pipelinePacked,
    490                                        GLenum pname,
    491                                        GLint *params,
    492                                        angle::ParamCapture *paramCapture);
    493 void CaptureGetProgramResourceIndex_name(const State &glState,
    494                                         bool isCallValid,
    495                                         ShaderProgramID programPacked,
    496                                         GLenum programInterface,
    497                                         const GLchar *name,
    498                                         angle::ParamCapture *paramCapture);
    499 void CaptureGetProgramResourceLocation_name(const State &glState,
    500                                            bool isCallValid,
    501                                            ShaderProgramID programPacked,
    502                                            GLenum programInterface,
    503                                            const GLchar *name,
    504                                            angle::ParamCapture *paramCapture);
    505 void CaptureGetProgramResourceName_length(const State &glState,
    506                                          bool isCallValid,
    507                                          ShaderProgramID programPacked,
    508                                          GLenum programInterface,
    509                                          GLuint index,
    510                                          GLsizei bufSize,
    511                                          GLsizei *length,
    512                                          GLchar *name,
    513                                          angle::ParamCapture *paramCapture);
    514 void CaptureGetProgramResourceName_name(const State &glState,
    515                                        bool isCallValid,
    516                                        ShaderProgramID programPacked,
    517                                        GLenum programInterface,
    518                                        GLuint index,
    519                                        GLsizei bufSize,
    520                                        GLsizei *length,
    521                                        GLchar *name,
    522                                        angle::ParamCapture *paramCapture);
    523 void CaptureGetProgramResourceiv_props(const State &glState,
    524                                       bool isCallValid,
    525                                       ShaderProgramID programPacked,
    526                                       GLenum programInterface,
    527                                       GLuint index,
    528                                       GLsizei propCount,
    529                                       const GLenum *props,
    530                                       GLsizei count,
    531                                       GLsizei *length,
    532                                       GLint *params,
    533                                       angle::ParamCapture *paramCapture);
    534 void CaptureGetProgramResourceiv_length(const State &glState,
    535                                        bool isCallValid,
    536                                        ShaderProgramID programPacked,
    537                                        GLenum programInterface,
    538                                        GLuint index,
    539                                        GLsizei propCount,
    540                                        const GLenum *props,
    541                                        GLsizei count,
    542                                        GLsizei *length,
    543                                        GLint *params,
    544                                        angle::ParamCapture *paramCapture);
    545 void CaptureGetProgramResourceiv_params(const State &glState,
    546                                        bool isCallValid,
    547                                        ShaderProgramID programPacked,
    548                                        GLenum programInterface,
    549                                        GLuint index,
    550                                        GLsizei propCount,
    551                                        const GLenum *props,
    552                                        GLsizei count,
    553                                        GLsizei *length,
    554                                        GLint *params,
    555                                        angle::ParamCapture *paramCapture);
    556 void CaptureGetTexLevelParameterfv_params(const State &glState,
    557                                          bool isCallValid,
    558                                          TextureTarget targetPacked,
    559                                          GLint level,
    560                                          GLenum pname,
    561                                          GLfloat *params,
    562                                          angle::ParamCapture *paramCapture);
    563 void CaptureGetTexLevelParameteriv_params(const State &glState,
    564                                          bool isCallValid,
    565                                          TextureTarget targetPacked,
    566                                          GLint level,
    567                                          GLenum pname,
    568                                          GLint *params,
    569                                          angle::ParamCapture *paramCapture);
    570 void CaptureProgramUniform1fv_value(const State &glState,
    571                                    bool isCallValid,
    572                                    ShaderProgramID programPacked,
    573                                    UniformLocation locationPacked,
    574                                    GLsizei count,
    575                                    const GLfloat *value,
    576                                    angle::ParamCapture *paramCapture);
    577 void CaptureProgramUniform1iv_value(const State &glState,
    578                                    bool isCallValid,
    579                                    ShaderProgramID programPacked,
    580                                    UniformLocation locationPacked,
    581                                    GLsizei count,
    582                                    const GLint *value,
    583                                    angle::ParamCapture *paramCapture);
    584 void CaptureProgramUniform1uiv_value(const State &glState,
    585                                     bool isCallValid,
    586                                     ShaderProgramID programPacked,
    587                                     UniformLocation locationPacked,
    588                                     GLsizei count,
    589                                     const GLuint *value,
    590                                     angle::ParamCapture *paramCapture);
    591 void CaptureProgramUniform2fv_value(const State &glState,
    592                                    bool isCallValid,
    593                                    ShaderProgramID programPacked,
    594                                    UniformLocation locationPacked,
    595                                    GLsizei count,
    596                                    const GLfloat *value,
    597                                    angle::ParamCapture *paramCapture);
    598 void CaptureProgramUniform2iv_value(const State &glState,
    599                                    bool isCallValid,
    600                                    ShaderProgramID programPacked,
    601                                    UniformLocation locationPacked,
    602                                    GLsizei count,
    603                                    const GLint *value,
    604                                    angle::ParamCapture *paramCapture);
    605 void CaptureProgramUniform2uiv_value(const State &glState,
    606                                     bool isCallValid,
    607                                     ShaderProgramID programPacked,
    608                                     UniformLocation locationPacked,
    609                                     GLsizei count,
    610                                     const GLuint *value,
    611                                     angle::ParamCapture *paramCapture);
    612 void CaptureProgramUniform3fv_value(const State &glState,
    613                                    bool isCallValid,
    614                                    ShaderProgramID programPacked,
    615                                    UniformLocation locationPacked,
    616                                    GLsizei count,
    617                                    const GLfloat *value,
    618                                    angle::ParamCapture *paramCapture);
    619 void CaptureProgramUniform3iv_value(const State &glState,
    620                                    bool isCallValid,
    621                                    ShaderProgramID programPacked,
    622                                    UniformLocation locationPacked,
    623                                    GLsizei count,
    624                                    const GLint *value,
    625                                    angle::ParamCapture *paramCapture);
    626 void CaptureProgramUniform3uiv_value(const State &glState,
    627                                     bool isCallValid,
    628                                     ShaderProgramID programPacked,
    629                                     UniformLocation locationPacked,
    630                                     GLsizei count,
    631                                     const GLuint *value,
    632                                     angle::ParamCapture *paramCapture);
    633 void CaptureProgramUniform4fv_value(const State &glState,
    634                                    bool isCallValid,
    635                                    ShaderProgramID programPacked,
    636                                    UniformLocation locationPacked,
    637                                    GLsizei count,
    638                                    const GLfloat *value,
    639                                    angle::ParamCapture *paramCapture);
    640 void CaptureProgramUniform4iv_value(const State &glState,
    641                                    bool isCallValid,
    642                                    ShaderProgramID programPacked,
    643                                    UniformLocation locationPacked,
    644                                    GLsizei count,
    645                                    const GLint *value,
    646                                    angle::ParamCapture *paramCapture);
    647 void CaptureProgramUniform4uiv_value(const State &glState,
    648                                     bool isCallValid,
    649                                     ShaderProgramID programPacked,
    650                                     UniformLocation locationPacked,
    651                                     GLsizei count,
    652                                     const GLuint *value,
    653                                     angle::ParamCapture *paramCapture);
    654 void CaptureProgramUniformMatrix2fv_value(const State &glState,
    655                                          bool isCallValid,
    656                                          ShaderProgramID programPacked,
    657                                          UniformLocation locationPacked,
    658                                          GLsizei count,
    659                                          GLboolean transpose,
    660                                          const GLfloat *value,
    661                                          angle::ParamCapture *paramCapture);
    662 void CaptureProgramUniformMatrix2x3fv_value(const State &glState,
    663                                            bool isCallValid,
    664                                            ShaderProgramID programPacked,
    665                                            UniformLocation locationPacked,
    666                                            GLsizei count,
    667                                            GLboolean transpose,
    668                                            const GLfloat *value,
    669                                            angle::ParamCapture *paramCapture);
    670 void CaptureProgramUniformMatrix2x4fv_value(const State &glState,
    671                                            bool isCallValid,
    672                                            ShaderProgramID programPacked,
    673                                            UniformLocation locationPacked,
    674                                            GLsizei count,
    675                                            GLboolean transpose,
    676                                            const GLfloat *value,
    677                                            angle::ParamCapture *paramCapture);
    678 void CaptureProgramUniformMatrix3fv_value(const State &glState,
    679                                          bool isCallValid,
    680                                          ShaderProgramID programPacked,
    681                                          UniformLocation locationPacked,
    682                                          GLsizei count,
    683                                          GLboolean transpose,
    684                                          const GLfloat *value,
    685                                          angle::ParamCapture *paramCapture);
    686 void CaptureProgramUniformMatrix3x2fv_value(const State &glState,
    687                                            bool isCallValid,
    688                                            ShaderProgramID programPacked,
    689                                            UniformLocation locationPacked,
    690                                            GLsizei count,
    691                                            GLboolean transpose,
    692                                            const GLfloat *value,
    693                                            angle::ParamCapture *paramCapture);
    694 void CaptureProgramUniformMatrix3x4fv_value(const State &glState,
    695                                            bool isCallValid,
    696                                            ShaderProgramID programPacked,
    697                                            UniformLocation locationPacked,
    698                                            GLsizei count,
    699                                            GLboolean transpose,
    700                                            const GLfloat *value,
    701                                            angle::ParamCapture *paramCapture);
    702 void CaptureProgramUniformMatrix4fv_value(const State &glState,
    703                                          bool isCallValid,
    704                                          ShaderProgramID programPacked,
    705                                          UniformLocation locationPacked,
    706                                          GLsizei count,
    707                                          GLboolean transpose,
    708                                          const GLfloat *value,
    709                                          angle::ParamCapture *paramCapture);
    710 void CaptureProgramUniformMatrix4x2fv_value(const State &glState,
    711                                            bool isCallValid,
    712                                            ShaderProgramID programPacked,
    713                                            UniformLocation locationPacked,
    714                                            GLsizei count,
    715                                            GLboolean transpose,
    716                                            const GLfloat *value,
    717                                            angle::ParamCapture *paramCapture);
    718 void CaptureProgramUniformMatrix4x3fv_value(const State &glState,
    719                                            bool isCallValid,
    720                                            ShaderProgramID programPacked,
    721                                            UniformLocation locationPacked,
    722                                            GLsizei count,
    723                                            GLboolean transpose,
    724                                            const GLfloat *value,
    725                                            angle::ParamCapture *paramCapture);
    726 }  // namespace gl
    727 
    728 #endif  // LIBANGLE_CAPTURE_GLES_3_1_AUTOGEN_H_