tor-browser

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

capture_gles_3_2_autogen.h (32472B)


      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_2_autogen.h:
      9 //   Capture functions for the OpenGL ES 3.2 entry points.
     10 
     11 #ifndef LIBANGLE_CAPTURE_GLES_3_2_AUTOGEN_H_
     12 #define LIBANGLE_CAPTURE_GLES_3_2_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 CaptureBlendBarrier(const State &glState, bool isCallValid);
     23 angle::CallCapture CaptureBlendEquationSeparatei(const State &glState,
     24                                                 bool isCallValid,
     25                                                 GLuint buf,
     26                                                 GLenum modeRGB,
     27                                                 GLenum modeAlpha);
     28 angle::CallCapture CaptureBlendEquationi(const State &glState,
     29                                         bool isCallValid,
     30                                         GLuint buf,
     31                                         GLenum mode);
     32 angle::CallCapture CaptureBlendFuncSeparatei(const State &glState,
     33                                             bool isCallValid,
     34                                             GLuint buf,
     35                                             GLenum srcRGB,
     36                                             GLenum dstRGB,
     37                                             GLenum srcAlpha,
     38                                             GLenum dstAlpha);
     39 angle::CallCapture CaptureBlendFunci(const State &glState,
     40                                     bool isCallValid,
     41                                     GLuint buf,
     42                                     GLenum src,
     43                                     GLenum dst);
     44 angle::CallCapture CaptureColorMaski(const State &glState,
     45                                     bool isCallValid,
     46                                     GLuint index,
     47                                     GLboolean r,
     48                                     GLboolean g,
     49                                     GLboolean b,
     50                                     GLboolean a);
     51 angle::CallCapture CaptureCopyImageSubData(const State &glState,
     52                                           bool isCallValid,
     53                                           GLuint srcName,
     54                                           GLenum srcTarget,
     55                                           GLint srcLevel,
     56                                           GLint srcX,
     57                                           GLint srcY,
     58                                           GLint srcZ,
     59                                           GLuint dstName,
     60                                           GLenum dstTarget,
     61                                           GLint dstLevel,
     62                                           GLint dstX,
     63                                           GLint dstY,
     64                                           GLint dstZ,
     65                                           GLsizei srcWidth,
     66                                           GLsizei srcHeight,
     67                                           GLsizei srcDepth);
     68 angle::CallCapture CaptureDebugMessageCallback(const State &glState,
     69                                               bool isCallValid,
     70                                               GLDEBUGPROC callback,
     71                                               const void *userParam);
     72 angle::CallCapture CaptureDebugMessageControl(const State &glState,
     73                                              bool isCallValid,
     74                                              GLenum source,
     75                                              GLenum type,
     76                                              GLenum severity,
     77                                              GLsizei count,
     78                                              const GLuint *ids,
     79                                              GLboolean enabled);
     80 angle::CallCapture CaptureDebugMessageInsert(const State &glState,
     81                                             bool isCallValid,
     82                                             GLenum source,
     83                                             GLenum type,
     84                                             GLuint id,
     85                                             GLenum severity,
     86                                             GLsizei length,
     87                                             const GLchar *buf);
     88 angle::CallCapture CaptureDisablei(const State &glState,
     89                                   bool isCallValid,
     90                                   GLenum target,
     91                                   GLuint index);
     92 angle::CallCapture CaptureDrawElementsBaseVertex(const State &glState,
     93                                                 bool isCallValid,
     94                                                 PrimitiveMode modePacked,
     95                                                 GLsizei count,
     96                                                 DrawElementsType typePacked,
     97                                                 const void *indices,
     98                                                 GLint basevertex);
     99 angle::CallCapture CaptureDrawElementsInstancedBaseVertex(const State &glState,
    100                                                          bool isCallValid,
    101                                                          PrimitiveMode modePacked,
    102                                                          GLsizei count,
    103                                                          DrawElementsType typePacked,
    104                                                          const void *indices,
    105                                                          GLsizei instancecount,
    106                                                          GLint basevertex);
    107 angle::CallCapture CaptureDrawRangeElementsBaseVertex(const State &glState,
    108                                                      bool isCallValid,
    109                                                      PrimitiveMode modePacked,
    110                                                      GLuint start,
    111                                                      GLuint end,
    112                                                      GLsizei count,
    113                                                      DrawElementsType typePacked,
    114                                                      const void *indices,
    115                                                      GLint basevertex);
    116 angle::CallCapture CaptureEnablei(const State &glState,
    117                                  bool isCallValid,
    118                                  GLenum target,
    119                                  GLuint index);
    120 angle::CallCapture CaptureFramebufferTexture(const State &glState,
    121                                             bool isCallValid,
    122                                             GLenum target,
    123                                             GLenum attachment,
    124                                             TextureID texturePacked,
    125                                             GLint level);
    126 angle::CallCapture CaptureGetDebugMessageLog(const State &glState,
    127                                             bool isCallValid,
    128                                             GLuint count,
    129                                             GLsizei bufSize,
    130                                             GLenum *sources,
    131                                             GLenum *types,
    132                                             GLuint *ids,
    133                                             GLenum *severities,
    134                                             GLsizei *lengths,
    135                                             GLchar *messageLog,
    136                                             GLuint returnValue);
    137 angle::CallCapture CaptureGetGraphicsResetStatus(const State &glState,
    138                                                 bool isCallValid,
    139                                                 GLenum returnValue);
    140 angle::CallCapture CaptureGetObjectLabel(const State &glState,
    141                                         bool isCallValid,
    142                                         GLenum identifier,
    143                                         GLuint name,
    144                                         GLsizei bufSize,
    145                                         GLsizei *length,
    146                                         GLchar *label);
    147 angle::CallCapture CaptureGetObjectPtrLabel(const State &glState,
    148                                            bool isCallValid,
    149                                            const void *ptr,
    150                                            GLsizei bufSize,
    151                                            GLsizei *length,
    152                                            GLchar *label);
    153 angle::CallCapture CaptureGetPointerv(const State &glState,
    154                                      bool isCallValid,
    155                                      GLenum pname,
    156                                      void **params);
    157 angle::CallCapture CaptureGetSamplerParameterIiv(const State &glState,
    158                                                 bool isCallValid,
    159                                                 SamplerID samplerPacked,
    160                                                 GLenum pname,
    161                                                 GLint *params);
    162 angle::CallCapture CaptureGetSamplerParameterIuiv(const State &glState,
    163                                                  bool isCallValid,
    164                                                  SamplerID samplerPacked,
    165                                                  GLenum pname,
    166                                                  GLuint *params);
    167 angle::CallCapture CaptureGetTexParameterIiv(const State &glState,
    168                                             bool isCallValid,
    169                                             TextureType targetPacked,
    170                                             GLenum pname,
    171                                             GLint *params);
    172 angle::CallCapture CaptureGetTexParameterIuiv(const State &glState,
    173                                              bool isCallValid,
    174                                              TextureType targetPacked,
    175                                              GLenum pname,
    176                                              GLuint *params);
    177 angle::CallCapture CaptureGetnUniformfv(const State &glState,
    178                                        bool isCallValid,
    179                                        ShaderProgramID programPacked,
    180                                        UniformLocation locationPacked,
    181                                        GLsizei bufSize,
    182                                        GLfloat *params);
    183 angle::CallCapture CaptureGetnUniformiv(const State &glState,
    184                                        bool isCallValid,
    185                                        ShaderProgramID programPacked,
    186                                        UniformLocation locationPacked,
    187                                        GLsizei bufSize,
    188                                        GLint *params);
    189 angle::CallCapture CaptureGetnUniformuiv(const State &glState,
    190                                         bool isCallValid,
    191                                         ShaderProgramID programPacked,
    192                                         UniformLocation locationPacked,
    193                                         GLsizei bufSize,
    194                                         GLuint *params);
    195 angle::CallCapture CaptureIsEnabledi(const State &glState,
    196                                     bool isCallValid,
    197                                     GLenum target,
    198                                     GLuint index,
    199                                     GLboolean returnValue);
    200 angle::CallCapture CaptureMinSampleShading(const State &glState, bool isCallValid, GLfloat value);
    201 angle::CallCapture CaptureObjectLabel(const State &glState,
    202                                      bool isCallValid,
    203                                      GLenum identifier,
    204                                      GLuint name,
    205                                      GLsizei length,
    206                                      const GLchar *label);
    207 angle::CallCapture CaptureObjectPtrLabel(const State &glState,
    208                                         bool isCallValid,
    209                                         const void *ptr,
    210                                         GLsizei length,
    211                                         const GLchar *label);
    212 angle::CallCapture CapturePatchParameteri(const State &glState,
    213                                          bool isCallValid,
    214                                          GLenum pname,
    215                                          GLint value);
    216 angle::CallCapture CapturePopDebugGroup(const State &glState, bool isCallValid);
    217 angle::CallCapture CapturePrimitiveBoundingBox(const State &glState,
    218                                               bool isCallValid,
    219                                               GLfloat minX,
    220                                               GLfloat minY,
    221                                               GLfloat minZ,
    222                                               GLfloat minW,
    223                                               GLfloat maxX,
    224                                               GLfloat maxY,
    225                                               GLfloat maxZ,
    226                                               GLfloat maxW);
    227 angle::CallCapture CapturePushDebugGroup(const State &glState,
    228                                         bool isCallValid,
    229                                         GLenum source,
    230                                         GLuint id,
    231                                         GLsizei length,
    232                                         const GLchar *message);
    233 angle::CallCapture CaptureReadnPixels(const State &glState,
    234                                      bool isCallValid,
    235                                      GLint x,
    236                                      GLint y,
    237                                      GLsizei width,
    238                                      GLsizei height,
    239                                      GLenum format,
    240                                      GLenum type,
    241                                      GLsizei bufSize,
    242                                      void *data);
    243 angle::CallCapture CaptureSamplerParameterIiv(const State &glState,
    244                                              bool isCallValid,
    245                                              SamplerID samplerPacked,
    246                                              GLenum pname,
    247                                              const GLint *param);
    248 angle::CallCapture CaptureSamplerParameterIuiv(const State &glState,
    249                                               bool isCallValid,
    250                                               SamplerID samplerPacked,
    251                                               GLenum pname,
    252                                               const GLuint *param);
    253 angle::CallCapture CaptureTexBuffer(const State &glState,
    254                                    bool isCallValid,
    255                                    TextureType targetPacked,
    256                                    GLenum internalformat,
    257                                    BufferID bufferPacked);
    258 angle::CallCapture CaptureTexBufferRange(const State &glState,
    259                                         bool isCallValid,
    260                                         TextureType targetPacked,
    261                                         GLenum internalformat,
    262                                         BufferID bufferPacked,
    263                                         GLintptr offset,
    264                                         GLsizeiptr size);
    265 angle::CallCapture CaptureTexParameterIiv(const State &glState,
    266                                          bool isCallValid,
    267                                          TextureType targetPacked,
    268                                          GLenum pname,
    269                                          const GLint *params);
    270 angle::CallCapture CaptureTexParameterIuiv(const State &glState,
    271                                           bool isCallValid,
    272                                           TextureType targetPacked,
    273                                           GLenum pname,
    274                                           const GLuint *params);
    275 angle::CallCapture CaptureTexStorage3DMultisample(const State &glState,
    276                                                  bool isCallValid,
    277                                                  TextureType targetPacked,
    278                                                  GLsizei samples,
    279                                                  GLenum internalformat,
    280                                                  GLsizei width,
    281                                                  GLsizei height,
    282                                                  GLsizei depth,
    283                                                  GLboolean fixedsamplelocations);
    284 
    285 // Parameter Captures
    286 
    287 void CaptureDebugMessageCallback_userParam(const State &glState,
    288                                           bool isCallValid,
    289                                           GLDEBUGPROC callback,
    290                                           const void *userParam,
    291                                           angle::ParamCapture *paramCapture);
    292 void CaptureDebugMessageControl_ids(const State &glState,
    293                                    bool isCallValid,
    294                                    GLenum source,
    295                                    GLenum type,
    296                                    GLenum severity,
    297                                    GLsizei count,
    298                                    const GLuint *ids,
    299                                    GLboolean enabled,
    300                                    angle::ParamCapture *paramCapture);
    301 void CaptureDebugMessageInsert_buf(const State &glState,
    302                                   bool isCallValid,
    303                                   GLenum source,
    304                                   GLenum type,
    305                                   GLuint id,
    306                                   GLenum severity,
    307                                   GLsizei length,
    308                                   const GLchar *buf,
    309                                   angle::ParamCapture *paramCapture);
    310 void CaptureDrawElementsBaseVertex_indices(const State &glState,
    311                                           bool isCallValid,
    312                                           PrimitiveMode modePacked,
    313                                           GLsizei count,
    314                                           DrawElementsType typePacked,
    315                                           const void *indices,
    316                                           GLint basevertex,
    317                                           angle::ParamCapture *paramCapture);
    318 void CaptureDrawElementsInstancedBaseVertex_indices(const State &glState,
    319                                                    bool isCallValid,
    320                                                    PrimitiveMode modePacked,
    321                                                    GLsizei count,
    322                                                    DrawElementsType typePacked,
    323                                                    const void *indices,
    324                                                    GLsizei instancecount,
    325                                                    GLint basevertex,
    326                                                    angle::ParamCapture *paramCapture);
    327 void CaptureDrawRangeElementsBaseVertex_indices(const State &glState,
    328                                                bool isCallValid,
    329                                                PrimitiveMode modePacked,
    330                                                GLuint start,
    331                                                GLuint end,
    332                                                GLsizei count,
    333                                                DrawElementsType typePacked,
    334                                                const void *indices,
    335                                                GLint basevertex,
    336                                                angle::ParamCapture *paramCapture);
    337 void CaptureGetDebugMessageLog_sources(const State &glState,
    338                                       bool isCallValid,
    339                                       GLuint count,
    340                                       GLsizei bufSize,
    341                                       GLenum *sources,
    342                                       GLenum *types,
    343                                       GLuint *ids,
    344                                       GLenum *severities,
    345                                       GLsizei *lengths,
    346                                       GLchar *messageLog,
    347                                       angle::ParamCapture *paramCapture);
    348 void CaptureGetDebugMessageLog_types(const State &glState,
    349                                     bool isCallValid,
    350                                     GLuint count,
    351                                     GLsizei bufSize,
    352                                     GLenum *sources,
    353                                     GLenum *types,
    354                                     GLuint *ids,
    355                                     GLenum *severities,
    356                                     GLsizei *lengths,
    357                                     GLchar *messageLog,
    358                                     angle::ParamCapture *paramCapture);
    359 void CaptureGetDebugMessageLog_ids(const State &glState,
    360                                   bool isCallValid,
    361                                   GLuint count,
    362                                   GLsizei bufSize,
    363                                   GLenum *sources,
    364                                   GLenum *types,
    365                                   GLuint *ids,
    366                                   GLenum *severities,
    367                                   GLsizei *lengths,
    368                                   GLchar *messageLog,
    369                                   angle::ParamCapture *paramCapture);
    370 void CaptureGetDebugMessageLog_severities(const State &glState,
    371                                          bool isCallValid,
    372                                          GLuint count,
    373                                          GLsizei bufSize,
    374                                          GLenum *sources,
    375                                          GLenum *types,
    376                                          GLuint *ids,
    377                                          GLenum *severities,
    378                                          GLsizei *lengths,
    379                                          GLchar *messageLog,
    380                                          angle::ParamCapture *paramCapture);
    381 void CaptureGetDebugMessageLog_lengths(const State &glState,
    382                                       bool isCallValid,
    383                                       GLuint count,
    384                                       GLsizei bufSize,
    385                                       GLenum *sources,
    386                                       GLenum *types,
    387                                       GLuint *ids,
    388                                       GLenum *severities,
    389                                       GLsizei *lengths,
    390                                       GLchar *messageLog,
    391                                       angle::ParamCapture *paramCapture);
    392 void CaptureGetDebugMessageLog_messageLog(const State &glState,
    393                                          bool isCallValid,
    394                                          GLuint count,
    395                                          GLsizei bufSize,
    396                                          GLenum *sources,
    397                                          GLenum *types,
    398                                          GLuint *ids,
    399                                          GLenum *severities,
    400                                          GLsizei *lengths,
    401                                          GLchar *messageLog,
    402                                          angle::ParamCapture *paramCapture);
    403 void CaptureGetObjectLabel_length(const State &glState,
    404                                  bool isCallValid,
    405                                  GLenum identifier,
    406                                  GLuint name,
    407                                  GLsizei bufSize,
    408                                  GLsizei *length,
    409                                  GLchar *label,
    410                                  angle::ParamCapture *paramCapture);
    411 void CaptureGetObjectLabel_label(const State &glState,
    412                                 bool isCallValid,
    413                                 GLenum identifier,
    414                                 GLuint name,
    415                                 GLsizei bufSize,
    416                                 GLsizei *length,
    417                                 GLchar *label,
    418                                 angle::ParamCapture *paramCapture);
    419 void CaptureGetObjectPtrLabel_ptr(const State &glState,
    420                                  bool isCallValid,
    421                                  const void *ptr,
    422                                  GLsizei bufSize,
    423                                  GLsizei *length,
    424                                  GLchar *label,
    425                                  angle::ParamCapture *paramCapture);
    426 void CaptureGetObjectPtrLabel_length(const State &glState,
    427                                     bool isCallValid,
    428                                     const void *ptr,
    429                                     GLsizei bufSize,
    430                                     GLsizei *length,
    431                                     GLchar *label,
    432                                     angle::ParamCapture *paramCapture);
    433 void CaptureGetObjectPtrLabel_label(const State &glState,
    434                                    bool isCallValid,
    435                                    const void *ptr,
    436                                    GLsizei bufSize,
    437                                    GLsizei *length,
    438                                    GLchar *label,
    439                                    angle::ParamCapture *paramCapture);
    440 void CaptureGetPointerv_params(const State &glState,
    441                               bool isCallValid,
    442                               GLenum pname,
    443                               void **params,
    444                               angle::ParamCapture *paramCapture);
    445 void CaptureGetSamplerParameterIiv_params(const State &glState,
    446                                          bool isCallValid,
    447                                          SamplerID samplerPacked,
    448                                          GLenum pname,
    449                                          GLint *params,
    450                                          angle::ParamCapture *paramCapture);
    451 void CaptureGetSamplerParameterIuiv_params(const State &glState,
    452                                           bool isCallValid,
    453                                           SamplerID samplerPacked,
    454                                           GLenum pname,
    455                                           GLuint *params,
    456                                           angle::ParamCapture *paramCapture);
    457 void CaptureGetTexParameterIiv_params(const State &glState,
    458                                      bool isCallValid,
    459                                      TextureType targetPacked,
    460                                      GLenum pname,
    461                                      GLint *params,
    462                                      angle::ParamCapture *paramCapture);
    463 void CaptureGetTexParameterIuiv_params(const State &glState,
    464                                       bool isCallValid,
    465                                       TextureType targetPacked,
    466                                       GLenum pname,
    467                                       GLuint *params,
    468                                       angle::ParamCapture *paramCapture);
    469 void CaptureGetnUniformfv_params(const State &glState,
    470                                 bool isCallValid,
    471                                 ShaderProgramID programPacked,
    472                                 UniformLocation locationPacked,
    473                                 GLsizei bufSize,
    474                                 GLfloat *params,
    475                                 angle::ParamCapture *paramCapture);
    476 void CaptureGetnUniformiv_params(const State &glState,
    477                                 bool isCallValid,
    478                                 ShaderProgramID programPacked,
    479                                 UniformLocation locationPacked,
    480                                 GLsizei bufSize,
    481                                 GLint *params,
    482                                 angle::ParamCapture *paramCapture);
    483 void CaptureGetnUniformuiv_params(const State &glState,
    484                                  bool isCallValid,
    485                                  ShaderProgramID programPacked,
    486                                  UniformLocation locationPacked,
    487                                  GLsizei bufSize,
    488                                  GLuint *params,
    489                                  angle::ParamCapture *paramCapture);
    490 void CaptureObjectLabel_label(const State &glState,
    491                              bool isCallValid,
    492                              GLenum identifier,
    493                              GLuint name,
    494                              GLsizei length,
    495                              const GLchar *label,
    496                              angle::ParamCapture *paramCapture);
    497 void CaptureObjectPtrLabel_ptr(const State &glState,
    498                               bool isCallValid,
    499                               const void *ptr,
    500                               GLsizei length,
    501                               const GLchar *label,
    502                               angle::ParamCapture *paramCapture);
    503 void CaptureObjectPtrLabel_label(const State &glState,
    504                                 bool isCallValid,
    505                                 const void *ptr,
    506                                 GLsizei length,
    507                                 const GLchar *label,
    508                                 angle::ParamCapture *paramCapture);
    509 void CapturePushDebugGroup_message(const State &glState,
    510                                   bool isCallValid,
    511                                   GLenum source,
    512                                   GLuint id,
    513                                   GLsizei length,
    514                                   const GLchar *message,
    515                                   angle::ParamCapture *paramCapture);
    516 void CaptureReadnPixels_data(const State &glState,
    517                             bool isCallValid,
    518                             GLint x,
    519                             GLint y,
    520                             GLsizei width,
    521                             GLsizei height,
    522                             GLenum format,
    523                             GLenum type,
    524                             GLsizei bufSize,
    525                             void *data,
    526                             angle::ParamCapture *paramCapture);
    527 void CaptureSamplerParameterIiv_param(const State &glState,
    528                                      bool isCallValid,
    529                                      SamplerID samplerPacked,
    530                                      GLenum pname,
    531                                      const GLint *param,
    532                                      angle::ParamCapture *paramCapture);
    533 void CaptureSamplerParameterIuiv_param(const State &glState,
    534                                       bool isCallValid,
    535                                       SamplerID samplerPacked,
    536                                       GLenum pname,
    537                                       const GLuint *param,
    538                                       angle::ParamCapture *paramCapture);
    539 void CaptureTexParameterIiv_params(const State &glState,
    540                                   bool isCallValid,
    541                                   TextureType targetPacked,
    542                                   GLenum pname,
    543                                   const GLint *params,
    544                                   angle::ParamCapture *paramCapture);
    545 void CaptureTexParameterIuiv_params(const State &glState,
    546                                    bool isCallValid,
    547                                    TextureType targetPacked,
    548                                    GLenum pname,
    549                                    const GLuint *params,
    550                                    angle::ParamCapture *paramCapture);
    551 }  // namespace gl
    552 
    553 #endif  // LIBANGLE_CAPTURE_GLES_3_2_AUTOGEN_H_