[ tor-browser ].git.dasho

validationGL1.cpp (62123B)
      1 //
      2 // Copyright 2019 The ANGLE Project Authors. All rights reserved.
      3 // Use of this source code is governed by a BSD-style license that can be
      4 // found in the LICENSE file.
      5 //
      6 
      7 // validationGL1.cpp: Validation functions for OpenGL 1.0 entry point parameters
      8 
      9 #include "libANGLE/validationGL1_autogen.h"
     10 
     11 namespace gl
     12 {
     13 
     14 bool ValidateAccum(const Context *, angle::EntryPoint entryPoint, GLenum op, GLfloat value)
     15 {
     16    return true;
     17 }
     18 
     19 bool ValidateBegin(const Context *, angle::EntryPoint entryPoint, GLenum mode)
     20 {
     21    return true;
     22 }
     23 
     24 bool ValidateBitmap(const Context *,
     25                    angle::EntryPoint entryPoint,
     26                    GLsizei width,
     27                    GLsizei height,
     28                    GLfloat xorig,
     29                    GLfloat yorig,
     30                    GLfloat xmove,
     31                    GLfloat ymove,
     32                    const GLubyte *bitmap)
     33 {
     34    return true;
     35 }
     36 
     37 bool ValidateCallList(const Context *, angle::EntryPoint entryPoint, GLuint list)
     38 {
     39    return true;
     40 }
     41 
     42 bool ValidateCallLists(const Context *,
     43                       angle::EntryPoint entryPoint,
     44                       GLsizei n,
     45                       GLenum type,
     46                       const void *lists)
     47 {
     48    return true;
     49 }
     50 
     51 bool ValidateClearAccum(const Context *,
     52                        angle::EntryPoint entryPoint,
     53                        GLfloat red,
     54                        GLfloat green,
     55                        GLfloat blue,
     56                        GLfloat alpha)
     57 {
     58    return true;
     59 }
     60 
     61 bool ValidateClearDepth(const Context *, angle::EntryPoint entryPoint, GLdouble depth)
     62 {
     63    return true;
     64 }
     65 
     66 bool ValidateClearIndex(const Context *, angle::EntryPoint entryPoint, GLfloat c)
     67 {
     68    return true;
     69 }
     70 
     71 bool ValidateClipPlane(const Context *,
     72                       angle::EntryPoint entryPoint,
     73                       GLenum plane,
     74                       const GLdouble *equation)
     75 {
     76    return true;
     77 }
     78 
     79 bool ValidateColor3b(const Context *,
     80                     angle::EntryPoint entryPoint,
     81                     GLbyte red,
     82                     GLbyte green,
     83                     GLbyte blue)
     84 {
     85    return true;
     86 }
     87 
     88 bool ValidateColor3bv(const Context *, angle::EntryPoint entryPoint, const GLbyte *v)
     89 {
     90    return true;
     91 }
     92 
     93 bool ValidateColor3d(const Context *,
     94                     angle::EntryPoint entryPoint,
     95                     GLdouble red,
     96                     GLdouble green,
     97                     GLdouble blue)
     98 {
     99    return true;
    100 }
    101 
    102 bool ValidateColor3dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
    103 {
    104    return true;
    105 }
    106 
    107 bool ValidateColor3f(const Context *,
    108                     angle::EntryPoint entryPoint,
    109                     GLfloat red,
    110                     GLfloat green,
    111                     GLfloat blue)
    112 {
    113    return true;
    114 }
    115 
    116 bool ValidateColor3fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
    117 {
    118    return true;
    119 }
    120 
    121 bool ValidateColor3i(const Context *,
    122                     angle::EntryPoint entryPoint,
    123                     GLint red,
    124                     GLint green,
    125                     GLint blue)
    126 {
    127    return true;
    128 }
    129 
    130 bool ValidateColor3iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
    131 {
    132    return true;
    133 }
    134 
    135 bool ValidateColor3s(const Context *,
    136                     angle::EntryPoint entryPoint,
    137                     GLshort red,
    138                     GLshort green,
    139                     GLshort blue)
    140 {
    141    return true;
    142 }
    143 
    144 bool ValidateColor3sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
    145 {
    146    return true;
    147 }
    148 
    149 bool ValidateColor3ub(const Context *,
    150                      angle::EntryPoint entryPoint,
    151                      GLubyte red,
    152                      GLubyte green,
    153                      GLubyte blue)
    154 {
    155    return true;
    156 }
    157 
    158 bool ValidateColor3ubv(const Context *, angle::EntryPoint entryPoint, const GLubyte *v)
    159 {
    160    return true;
    161 }
    162 
    163 bool ValidateColor3ui(const Context *,
    164                      angle::EntryPoint entryPoint,
    165                      GLuint red,
    166                      GLuint green,
    167                      GLuint blue)
    168 {
    169    return true;
    170 }
    171 
    172 bool ValidateColor3uiv(const Context *, angle::EntryPoint entryPoint, const GLuint *v)
    173 {
    174    return true;
    175 }
    176 
    177 bool ValidateColor3us(const Context *,
    178                      angle::EntryPoint entryPoint,
    179                      GLushort red,
    180                      GLushort green,
    181                      GLushort blue)
    182 {
    183    return true;
    184 }
    185 
    186 bool ValidateColor3usv(const Context *, angle::EntryPoint entryPoint, const GLushort *v)
    187 {
    188    return true;
    189 }
    190 
    191 bool ValidateColor4b(const Context *,
    192                     angle::EntryPoint entryPoint,
    193                     GLbyte red,
    194                     GLbyte green,
    195                     GLbyte blue,
    196                     GLbyte alpha)
    197 {
    198    return true;
    199 }
    200 
    201 bool ValidateColor4bv(const Context *, angle::EntryPoint entryPoint, const GLbyte *v)
    202 {
    203    return true;
    204 }
    205 
    206 bool ValidateColor4d(const Context *,
    207                     angle::EntryPoint entryPoint,
    208                     GLdouble red,
    209                     GLdouble green,
    210                     GLdouble blue,
    211                     GLdouble alpha)
    212 {
    213    return true;
    214 }
    215 
    216 bool ValidateColor4dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
    217 {
    218    return true;
    219 }
    220 
    221 bool ValidateColor4fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
    222 {
    223    return true;
    224 }
    225 
    226 bool ValidateColor4i(const Context *,
    227                     angle::EntryPoint entryPoint,
    228                     GLint red,
    229                     GLint green,
    230                     GLint blue,
    231                     GLint alpha)
    232 {
    233    return true;
    234 }
    235 
    236 bool ValidateColor4iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
    237 {
    238    return true;
    239 }
    240 
    241 bool ValidateColor4s(const Context *,
    242                     angle::EntryPoint entryPoint,
    243                     GLshort red,
    244                     GLshort green,
    245                     GLshort blue,
    246                     GLshort alpha)
    247 {
    248    return true;
    249 }
    250 
    251 bool ValidateColor4sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
    252 {
    253    return true;
    254 }
    255 
    256 bool ValidateColor4ubv(const Context *, angle::EntryPoint entryPoint, const GLubyte *v)
    257 {
    258    return true;
    259 }
    260 
    261 bool ValidateColor4ui(const Context *,
    262                      angle::EntryPoint entryPoint,
    263                      GLuint red,
    264                      GLuint green,
    265                      GLuint blue,
    266                      GLuint alpha)
    267 {
    268    return true;
    269 }
    270 
    271 bool ValidateColor4uiv(const Context *, angle::EntryPoint entryPoint, const GLuint *v)
    272 {
    273    return true;
    274 }
    275 
    276 bool ValidateColor4us(const Context *,
    277                      angle::EntryPoint entryPoint,
    278                      GLushort red,
    279                      GLushort green,
    280                      GLushort blue,
    281                      GLushort alpha)
    282 {
    283    return true;
    284 }
    285 
    286 bool ValidateColor4usv(const Context *, angle::EntryPoint entryPoint, const GLushort *v)
    287 {
    288    return true;
    289 }
    290 
    291 bool ValidateColorMaterial(const Context *, angle::EntryPoint entryPoint, GLenum face, GLenum mode)
    292 {
    293    return true;
    294 }
    295 
    296 bool ValidateCopyPixels(const Context *,
    297                        angle::EntryPoint entryPoint,
    298                        GLint x,
    299                        GLint y,
    300                        GLsizei width,
    301                        GLsizei height,
    302                        GLenum type)
    303 {
    304    return true;
    305 }
    306 
    307 bool ValidateDeleteLists(const Context *, angle::EntryPoint entryPoint, GLuint list, GLsizei range)
    308 {
    309    return true;
    310 }
    311 
    312 bool ValidateDepthRange(const Context *, angle::EntryPoint entryPoint, GLdouble n, GLdouble f)
    313 {
    314    return true;
    315 }
    316 
    317 bool ValidateDrawBuffer(const Context *, angle::EntryPoint entryPoint, GLenum buf)
    318 {
    319    return true;
    320 }
    321 
    322 bool ValidateDrawPixels(const Context *,
    323                        angle::EntryPoint entryPoint,
    324                        GLsizei width,
    325                        GLsizei height,
    326                        GLenum format,
    327                        GLenum type,
    328                        const void *pixels)
    329 {
    330    return true;
    331 }
    332 
    333 bool ValidateEdgeFlag(const Context *, angle::EntryPoint entryPoint, GLboolean flag)
    334 {
    335    return true;
    336 }
    337 
    338 bool ValidateEdgeFlagv(const Context *, angle::EntryPoint entryPoint, const GLboolean *flag)
    339 {
    340    return true;
    341 }
    342 
    343 bool ValidateEnd(const Context *, angle::EntryPoint entryPoint)
    344 {
    345    return true;
    346 }
    347 
    348 bool ValidateEndList(const Context *, angle::EntryPoint entryPoint)
    349 {
    350    return true;
    351 }
    352 
    353 bool ValidateEvalCoord1d(const Context *, angle::EntryPoint entryPoint, GLdouble u)
    354 {
    355    return true;
    356 }
    357 
    358 bool ValidateEvalCoord1dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *u)
    359 {
    360    return true;
    361 }
    362 
    363 bool ValidateEvalCoord1f(const Context *, angle::EntryPoint entryPoint, GLfloat u)
    364 {
    365    return true;
    366 }
    367 
    368 bool ValidateEvalCoord1fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *u)
    369 {
    370    return true;
    371 }
    372 
    373 bool ValidateEvalCoord2d(const Context *, angle::EntryPoint entryPoint, GLdouble u, GLdouble v)
    374 {
    375    return true;
    376 }
    377 
    378 bool ValidateEvalCoord2dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *u)
    379 {
    380    return true;
    381 }
    382 
    383 bool ValidateEvalCoord2f(const Context *, angle::EntryPoint entryPoint, GLfloat u, GLfloat v)
    384 {
    385    return true;
    386 }
    387 
    388 bool ValidateEvalCoord2fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *u)
    389 {
    390    return true;
    391 }
    392 
    393 bool ValidateEvalMesh1(const Context *,
    394                       angle::EntryPoint entryPoint,
    395                       GLenum mode,
    396                       GLint i1,
    397                       GLint i2)
    398 {
    399    return true;
    400 }
    401 
    402 bool ValidateEvalMesh2(const Context *,
    403                       angle::EntryPoint entryPoint,
    404                       GLenum mode,
    405                       GLint i1,
    406                       GLint i2,
    407                       GLint j1,
    408                       GLint j2)
    409 {
    410    return true;
    411 }
    412 
    413 bool ValidateEvalPoint1(const Context *, angle::EntryPoint entryPoint, GLint i)
    414 {
    415    return true;
    416 }
    417 
    418 bool ValidateEvalPoint2(const Context *, angle::EntryPoint entryPoint, GLint i, GLint j)
    419 {
    420    return true;
    421 }
    422 
    423 bool ValidateFeedbackBuffer(const Context *,
    424                            angle::EntryPoint entryPoint,
    425                            GLsizei size,
    426                            GLenum type,
    427                            const GLfloat *buffer)
    428 {
    429    return true;
    430 }
    431 
    432 bool ValidateFogi(const Context *, angle::EntryPoint entryPoint, GLenum pname, GLint param)
    433 {
    434    return true;
    435 }
    436 
    437 bool ValidateFogiv(const Context *, angle::EntryPoint entryPoint, GLenum pname, const GLint *params)
    438 {
    439    return true;
    440 }
    441 
    442 bool ValidateFrustum(const Context *,
    443                     angle::EntryPoint entryPoint,
    444                     GLdouble left,
    445                     GLdouble right,
    446                     GLdouble bottom,
    447                     GLdouble top,
    448                     GLdouble zNear,
    449                     GLdouble zFar)
    450 {
    451    return true;
    452 }
    453 
    454 bool ValidateGenLists(const Context *, angle::EntryPoint entryPoint, GLsizei range)
    455 {
    456    return true;
    457 }
    458 
    459 bool ValidateGetClipPlane(const Context *,
    460                          angle::EntryPoint entryPoint,
    461                          GLenum plane,
    462                          const GLdouble *equation)
    463 {
    464    return true;
    465 }
    466 
    467 bool ValidateGetDoublev(const Context *,
    468                        angle::EntryPoint entryPoint,
    469                        GLenum pname,
    470                        const GLdouble *data)
    471 {
    472    return true;
    473 }
    474 
    475 bool ValidateGetLightiv(const Context *,
    476                        angle::EntryPoint entryPoint,
    477                        GLenum light,
    478                        GLenum pname,
    479                        const GLint *params)
    480 {
    481    return true;
    482 }
    483 
    484 bool ValidateGetMapdv(const Context *,
    485                      angle::EntryPoint entryPoint,
    486                      GLenum target,
    487                      GLenum query,
    488                      const GLdouble *v)
    489 {
    490    return true;
    491 }
    492 
    493 bool ValidateGetMapfv(const Context *,
    494                      angle::EntryPoint entryPoint,
    495                      GLenum target,
    496                      GLenum query,
    497                      const GLfloat *v)
    498 {
    499    return true;
    500 }
    501 
    502 bool ValidateGetMapiv(const Context *,
    503                      angle::EntryPoint entryPoint,
    504                      GLenum target,
    505                      GLenum query,
    506                      const GLint *v)
    507 {
    508    return true;
    509 }
    510 
    511 bool ValidateGetMaterialiv(const Context *,
    512                           angle::EntryPoint entryPoint,
    513                           GLenum face,
    514                           GLenum pname,
    515                           const GLint *params)
    516 {
    517    return true;
    518 }
    519 
    520 bool ValidateGetPixelMapfv(const Context *,
    521                           angle::EntryPoint entryPoint,
    522                           GLenum map,
    523                           const GLfloat *values)
    524 {
    525    return true;
    526 }
    527 
    528 bool ValidateGetPixelMapuiv(const Context *,
    529                            angle::EntryPoint entryPoint,
    530                            GLenum map,
    531                            const GLuint *values)
    532 {
    533    return true;
    534 }
    535 
    536 bool ValidateGetPixelMapusv(const Context *,
    537                            angle::EntryPoint entryPoint,
    538                            GLenum map,
    539                            const GLushort *values)
    540 {
    541    return true;
    542 }
    543 
    544 bool ValidateGetPolygonStipple(const Context *, angle::EntryPoint entryPoint, const GLubyte *mask)
    545 {
    546    return true;
    547 }
    548 
    549 bool ValidateGetTexGendv(const Context *,
    550                         angle::EntryPoint entryPoint,
    551                         GLenum coord,
    552                         GLenum pname,
    553                         const GLdouble *params)
    554 {
    555    return true;
    556 }
    557 
    558 bool ValidateGetTexGenfv(const Context *,
    559                         angle::EntryPoint entryPoint,
    560                         GLenum coord,
    561                         GLenum pname,
    562                         const GLfloat *params)
    563 {
    564    return true;
    565 }
    566 
    567 bool ValidateGetTexGeniv(const Context *,
    568                         angle::EntryPoint entryPoint,
    569                         GLenum coord,
    570                         GLenum pname,
    571                         const GLint *params)
    572 {
    573    return true;
    574 }
    575 
    576 bool ValidateGetTexImage(const Context *,
    577                         angle::EntryPoint entryPoint,
    578                         TextureTarget target,
    579                         GLint level,
    580                         GLenum format,
    581                         GLenum type,
    582                         const void *pixels)
    583 {
    584    return true;
    585 }
    586 
    587 bool ValidateIndexMask(const Context *, angle::EntryPoint entryPoint, GLuint mask)
    588 {
    589    return true;
    590 }
    591 
    592 bool ValidateIndexd(const Context *, angle::EntryPoint entryPoint, GLdouble c)
    593 {
    594    return true;
    595 }
    596 
    597 bool ValidateIndexdv(const Context *, angle::EntryPoint entryPoint, const GLdouble *c)
    598 {
    599    return true;
    600 }
    601 
    602 bool ValidateIndexf(const Context *, angle::EntryPoint entryPoint, GLfloat c)
    603 {
    604    return true;
    605 }
    606 
    607 bool ValidateIndexfv(const Context *, angle::EntryPoint entryPoint, const GLfloat *c)
    608 {
    609    return true;
    610 }
    611 
    612 bool ValidateIndexi(const Context *, angle::EntryPoint entryPoint, GLint c)
    613 {
    614    return true;
    615 }
    616 
    617 bool ValidateIndexiv(const Context *, angle::EntryPoint entryPoint, const GLint *c)
    618 {
    619    return true;
    620 }
    621 
    622 bool ValidateIndexs(const Context *, angle::EntryPoint entryPoint, GLshort c)
    623 {
    624    return true;
    625 }
    626 
    627 bool ValidateIndexsv(const Context *, angle::EntryPoint entryPoint, const GLshort *c)
    628 {
    629    return true;
    630 }
    631 
    632 bool ValidateInitNames(const Context *, angle::EntryPoint entryPoint)
    633 {
    634    return true;
    635 }
    636 
    637 bool ValidateIsList(const Context *, angle::EntryPoint entryPoint, GLuint list)
    638 {
    639    return true;
    640 }
    641 
    642 bool ValidateLightModeli(const Context *, angle::EntryPoint entryPoint, GLenum pname, GLint param)
    643 {
    644    return true;
    645 }
    646 
    647 bool ValidateLightModeliv(const Context *,
    648                          angle::EntryPoint entryPoint,
    649                          GLenum pname,
    650                          const GLint *params)
    651 {
    652    return true;
    653 }
    654 
    655 bool ValidateLighti(const Context *,
    656                    angle::EntryPoint entryPoint,
    657                    GLenum light,
    658                    GLenum pname,
    659                    GLint param)
    660 {
    661    return true;
    662 }
    663 
    664 bool ValidateLightiv(const Context *,
    665                     angle::EntryPoint entryPoint,
    666                     GLenum light,
    667                     GLenum pname,
    668                     const GLint *params)
    669 {
    670    return true;
    671 }
    672 
    673 bool ValidateLineStipple(const Context *,
    674                         angle::EntryPoint entryPoint,
    675                         GLint factor,
    676                         GLushort pattern)
    677 {
    678    return true;
    679 }
    680 
    681 bool ValidateListBase(const Context *, angle::EntryPoint entryPoint, GLuint base)
    682 {
    683    return true;
    684 }
    685 
    686 bool ValidateLoadMatrixd(const Context *, angle::EntryPoint entryPoint, const GLdouble *m)
    687 {
    688    return true;
    689 }
    690 
    691 bool ValidateLoadName(const Context *, angle::EntryPoint entryPoint, GLuint name)
    692 {
    693    return true;
    694 }
    695 
    696 bool ValidateMap1d(const Context *,
    697                   angle::EntryPoint entryPoint,
    698                   GLenum target,
    699                   GLdouble u1,
    700                   GLdouble u2,
    701                   GLint stride,
    702                   GLint order,
    703                   const GLdouble *points)
    704 {
    705    return true;
    706 }
    707 
    708 bool ValidateMap1f(const Context *,
    709                   angle::EntryPoint entryPoint,
    710                   GLenum target,
    711                   GLfloat u1,
    712                   GLfloat u2,
    713                   GLint stride,
    714                   GLint order,
    715                   const GLfloat *points)
    716 {
    717    return true;
    718 }
    719 
    720 bool ValidateMap2d(const Context *,
    721                   angle::EntryPoint entryPoint,
    722                   GLenum target,
    723                   GLdouble u1,
    724                   GLdouble u2,
    725                   GLint ustride,
    726                   GLint uorder,
    727                   GLdouble v1,
    728                   GLdouble v2,
    729                   GLint vstride,
    730                   GLint vorder,
    731                   const GLdouble *points)
    732 {
    733    return true;
    734 }
    735 
    736 bool ValidateMap2f(const Context *,
    737                   angle::EntryPoint entryPoint,
    738                   GLenum target,
    739                   GLfloat u1,
    740                   GLfloat u2,
    741                   GLint ustride,
    742                   GLint uorder,
    743                   GLfloat v1,
    744                   GLfloat v2,
    745                   GLint vstride,
    746                   GLint vorder,
    747                   const GLfloat *points)
    748 {
    749    return true;
    750 }
    751 
    752 bool ValidateMapGrid1d(const Context *,
    753                       angle::EntryPoint entryPoint,
    754                       GLint un,
    755                       GLdouble u1,
    756                       GLdouble u2)
    757 {
    758    return true;
    759 }
    760 
    761 bool ValidateMapGrid1f(const Context *,
    762                       angle::EntryPoint entryPoint,
    763                       GLint un,
    764                       GLfloat u1,
    765                       GLfloat u2)
    766 {
    767    return true;
    768 }
    769 
    770 bool ValidateMapGrid2d(const Context *,
    771                       angle::EntryPoint entryPoint,
    772                       GLint un,
    773                       GLdouble u1,
    774                       GLdouble u2,
    775                       GLint vn,
    776                       GLdouble v1,
    777                       GLdouble v2)
    778 {
    779    return true;
    780 }
    781 
    782 bool ValidateMapGrid2f(const Context *,
    783                       angle::EntryPoint entryPoint,
    784                       GLint un,
    785                       GLfloat u1,
    786                       GLfloat u2,
    787                       GLint vn,
    788                       GLfloat v1,
    789                       GLfloat v2)
    790 {
    791    return true;
    792 }
    793 
    794 bool ValidateMateriali(const Context *,
    795                       angle::EntryPoint entryPoint,
    796                       GLenum face,
    797                       GLenum pname,
    798                       GLint param)
    799 {
    800    return true;
    801 }
    802 
    803 bool ValidateMaterialiv(const Context *,
    804                        angle::EntryPoint entryPoint,
    805                        GLenum face,
    806                        GLenum pname,
    807                        const GLint *params)
    808 {
    809    return true;
    810 }
    811 
    812 bool ValidateMultMatrixd(const Context *, angle::EntryPoint entryPoint, const GLdouble *m)
    813 {
    814    return true;
    815 }
    816 
    817 bool ValidateNewList(const Context *, angle::EntryPoint entryPoint, GLuint list, GLenum mode)
    818 {
    819    return true;
    820 }
    821 
    822 bool ValidateNormal3b(const Context *,
    823                      angle::EntryPoint entryPoint,
    824                      GLbyte nx,
    825                      GLbyte ny,
    826                      GLbyte nz)
    827 {
    828    return true;
    829 }
    830 
    831 bool ValidateNormal3bv(const Context *, angle::EntryPoint entryPoint, const GLbyte *v)
    832 {
    833    return true;
    834 }
    835 
    836 bool ValidateNormal3d(const Context *,
    837                      angle::EntryPoint entryPoint,
    838                      GLdouble nx,
    839                      GLdouble ny,
    840                      GLdouble nz)
    841 {
    842    return true;
    843 }
    844 
    845 bool ValidateNormal3dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
    846 {
    847    return true;
    848 }
    849 
    850 bool ValidateNormal3fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
    851 {
    852    return true;
    853 }
    854 
    855 bool ValidateNormal3i(const Context *, angle::EntryPoint entryPoint, GLint nx, GLint ny, GLint nz)
    856 {
    857    return true;
    858 }
    859 
    860 bool ValidateNormal3iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
    861 {
    862    return true;
    863 }
    864 
    865 bool ValidateNormal3s(const Context *,
    866                      angle::EntryPoint entryPoint,
    867                      GLshort nx,
    868                      GLshort ny,
    869                      GLshort nz)
    870 {
    871    return true;
    872 }
    873 
    874 bool ValidateNormal3sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
    875 {
    876    return true;
    877 }
    878 
    879 bool ValidateOrtho(const Context *,
    880                   angle::EntryPoint entryPoint,
    881                   GLdouble left,
    882                   GLdouble right,
    883                   GLdouble bottom,
    884                   GLdouble top,
    885                   GLdouble zNear,
    886                   GLdouble zFar)
    887 {
    888    return true;
    889 }
    890 
    891 bool ValidatePassThrough(const Context *, angle::EntryPoint entryPoint, GLfloat token)
    892 {
    893    return true;
    894 }
    895 
    896 bool ValidatePixelMapfv(const Context *,
    897                        angle::EntryPoint entryPoint,
    898                        GLenum map,
    899                        GLsizei mapsize,
    900                        const GLfloat *values)
    901 {
    902    return true;
    903 }
    904 
    905 bool ValidatePixelMapuiv(const Context *,
    906                         angle::EntryPoint entryPoint,
    907                         GLenum map,
    908                         GLsizei mapsize,
    909                         const GLuint *values)
    910 {
    911    return true;
    912 }
    913 
    914 bool ValidatePixelMapusv(const Context *,
    915                         angle::EntryPoint entryPoint,
    916                         GLenum map,
    917                         GLsizei mapsize,
    918                         const GLushort *values)
    919 {
    920    return true;
    921 }
    922 
    923 bool ValidatePixelStoref(const Context *, angle::EntryPoint entryPoint, GLenum pname, GLfloat param)
    924 {
    925    return true;
    926 }
    927 
    928 bool ValidatePixelTransferf(const Context *,
    929                            angle::EntryPoint entryPoint,
    930                            GLenum pname,
    931                            GLfloat param)
    932 {
    933    return true;
    934 }
    935 
    936 bool ValidatePixelTransferi(const Context *,
    937                            angle::EntryPoint entryPoint,
    938                            GLenum pname,
    939                            GLint param)
    940 {
    941    return true;
    942 }
    943 
    944 bool ValidatePixelZoom(const Context *,
    945                       angle::EntryPoint entryPoint,
    946                       GLfloat xfactor,
    947                       GLfloat yfactor)
    948 {
    949    return true;
    950 }
    951 
    952 bool ValidatePolygonMode(const Context *, angle::EntryPoint entryPoint, GLenum face, GLenum mode)
    953 {
    954    return true;
    955 }
    956 
    957 bool ValidatePolygonStipple(const Context *, angle::EntryPoint entryPoint, const GLubyte *mask)
    958 {
    959    return true;
    960 }
    961 
    962 bool ValidatePopAttrib(const Context *, angle::EntryPoint entryPoint)
    963 {
    964    return true;
    965 }
    966 
    967 bool ValidatePopName(const Context *, angle::EntryPoint entryPoint)
    968 {
    969    return true;
    970 }
    971 
    972 bool ValidatePushAttrib(const Context *, angle::EntryPoint entryPoint, GLbitfield mask)
    973 {
    974    return true;
    975 }
    976 
    977 bool ValidatePushName(const Context *, angle::EntryPoint entryPoint, GLuint name)
    978 {
    979    return true;
    980 }
    981 
    982 bool ValidateRasterPos2d(const Context *, angle::EntryPoint entryPoint, GLdouble x, GLdouble y)
    983 {
    984    return true;
    985 }
    986 
    987 bool ValidateRasterPos2dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
    988 {
    989    return true;
    990 }
    991 
    992 bool ValidateRasterPos2f(const Context *, angle::EntryPoint entryPoint, GLfloat x, GLfloat y)
    993 {
    994    return true;
    995 }
    996 
    997 bool ValidateRasterPos2fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
    998 {
    999    return true;
   1000 }
   1001 
   1002 bool ValidateRasterPos2i(const Context *, angle::EntryPoint entryPoint, GLint x, GLint y)
   1003 {
   1004    return true;
   1005 }
   1006 
   1007 bool ValidateRasterPos2iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
   1008 {
   1009    return true;
   1010 }
   1011 
   1012 bool ValidateRasterPos2s(const Context *, angle::EntryPoint entryPoint, GLshort x, GLshort y)
   1013 {
   1014    return true;
   1015 }
   1016 
   1017 bool ValidateRasterPos2sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
   1018 {
   1019    return true;
   1020 }
   1021 
   1022 bool ValidateRasterPos3d(const Context *,
   1023                         angle::EntryPoint entryPoint,
   1024                         GLdouble x,
   1025                         GLdouble y,
   1026                         GLdouble z)
   1027 {
   1028    return true;
   1029 }
   1030 
   1031 bool ValidateRasterPos3dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
   1032 {
   1033    return true;
   1034 }
   1035 
   1036 bool ValidateRasterPos3f(const Context *,
   1037                         angle::EntryPoint entryPoint,
   1038                         GLfloat x,
   1039                         GLfloat y,
   1040                         GLfloat z)
   1041 {
   1042    return true;
   1043 }
   1044 
   1045 bool ValidateRasterPos3fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
   1046 {
   1047    return true;
   1048 }
   1049 
   1050 bool ValidateRasterPos3i(const Context *, angle::EntryPoint entryPoint, GLint x, GLint y, GLint z)
   1051 {
   1052    return true;
   1053 }
   1054 
   1055 bool ValidateRasterPos3iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
   1056 {
   1057    return true;
   1058 }
   1059 
   1060 bool ValidateRasterPos3s(const Context *,
   1061                         angle::EntryPoint entryPoint,
   1062                         GLshort x,
   1063                         GLshort y,
   1064                         GLshort z)
   1065 {
   1066    return true;
   1067 }
   1068 
   1069 bool ValidateRasterPos3sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
   1070 {
   1071    return true;
   1072 }
   1073 
   1074 bool ValidateRasterPos4d(const Context *,
   1075                         angle::EntryPoint entryPoint,
   1076                         GLdouble x,
   1077                         GLdouble y,
   1078                         GLdouble z,
   1079                         GLdouble w)
   1080 {
   1081    return true;
   1082 }
   1083 
   1084 bool ValidateRasterPos4dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
   1085 {
   1086    return true;
   1087 }
   1088 
   1089 bool ValidateRasterPos4f(const Context *,
   1090                         angle::EntryPoint entryPoint,
   1091                         GLfloat x,
   1092                         GLfloat y,
   1093                         GLfloat z,
   1094                         GLfloat w)
   1095 {
   1096    return true;
   1097 }
   1098 
   1099 bool ValidateRasterPos4fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
   1100 {
   1101    return true;
   1102 }
   1103 
   1104 bool ValidateRasterPos4i(const Context *,
   1105                         angle::EntryPoint entryPoint,
   1106                         GLint x,
   1107                         GLint y,
   1108                         GLint z,
   1109                         GLint w)
   1110 {
   1111    return true;
   1112 }
   1113 
   1114 bool ValidateRasterPos4iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
   1115 {
   1116    return true;
   1117 }
   1118 
   1119 bool ValidateRasterPos4s(const Context *,
   1120                         angle::EntryPoint entryPoint,
   1121                         GLshort x,
   1122                         GLshort y,
   1123                         GLshort z,
   1124                         GLshort w)
   1125 {
   1126    return true;
   1127 }
   1128 
   1129 bool ValidateRasterPos4sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
   1130 {
   1131    return true;
   1132 }
   1133 
   1134 bool ValidateRectd(const Context *,
   1135                   angle::EntryPoint entryPoint,
   1136                   GLdouble x1,
   1137                   GLdouble y1,
   1138                   GLdouble x2,
   1139                   GLdouble y2)
   1140 {
   1141    return true;
   1142 }
   1143 
   1144 bool ValidateRectdv(const Context *,
   1145                    angle::EntryPoint entryPoint,
   1146                    const GLdouble *v1,
   1147                    const GLdouble *v2)
   1148 {
   1149    return true;
   1150 }
   1151 
   1152 bool ValidateRectf(const Context *,
   1153                   angle::EntryPoint entryPoint,
   1154                   GLfloat x1,
   1155                   GLfloat y1,
   1156                   GLfloat x2,
   1157                   GLfloat y2)
   1158 {
   1159    return true;
   1160 }
   1161 
   1162 bool ValidateRectfv(const Context *,
   1163                    angle::EntryPoint entryPoint,
   1164                    const GLfloat *v1,
   1165                    const GLfloat *v2)
   1166 {
   1167    return true;
   1168 }
   1169 
   1170 bool ValidateRecti(const Context *,
   1171                   angle::EntryPoint entryPoint,
   1172                   GLint x1,
   1173                   GLint y1,
   1174                   GLint x2,
   1175                   GLint y2)
   1176 {
   1177    return true;
   1178 }
   1179 
   1180 bool ValidateRectiv(const Context *, angle::EntryPoint entryPoint, const GLint *v1, const GLint *v2)
   1181 {
   1182    return true;
   1183 }
   1184 
   1185 bool ValidateRects(const Context *,
   1186                   angle::EntryPoint entryPoint,
   1187                   GLshort x1,
   1188                   GLshort y1,
   1189                   GLshort x2,
   1190                   GLshort y2)
   1191 {
   1192    return true;
   1193 }
   1194 
   1195 bool ValidateRectsv(const Context *,
   1196                    angle::EntryPoint entryPoint,
   1197                    const GLshort *v1,
   1198                    const GLshort *v2)
   1199 {
   1200    return true;
   1201 }
   1202 
   1203 bool ValidateRenderMode(const Context *, angle::EntryPoint entryPoint, GLenum mode)
   1204 {
   1205    return true;
   1206 }
   1207 
   1208 bool ValidateRotated(const Context *,
   1209                     angle::EntryPoint entryPoint,
   1210                     GLdouble angle,
   1211                     GLdouble x,
   1212                     GLdouble y,
   1213                     GLdouble z)
   1214 {
   1215    return true;
   1216 }
   1217 
   1218 bool ValidateScaled(const Context *,
   1219                    angle::EntryPoint entryPoint,
   1220                    GLdouble x,
   1221                    GLdouble y,
   1222                    GLdouble z)
   1223 {
   1224    return true;
   1225 }
   1226 
   1227 bool ValidateSelectBuffer(const Context *,
   1228                          angle::EntryPoint entryPoint,
   1229                          GLsizei size,
   1230                          const GLuint *buffer)
   1231 {
   1232    return true;
   1233 }
   1234 
   1235 bool ValidateTexCoord1d(const Context *, angle::EntryPoint entryPoint, GLdouble s)
   1236 {
   1237    return true;
   1238 }
   1239 
   1240 bool ValidateTexCoord1dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
   1241 {
   1242    return true;
   1243 }
   1244 
   1245 bool ValidateTexCoord1f(const Context *, angle::EntryPoint entryPoint, GLfloat s)
   1246 {
   1247    return true;
   1248 }
   1249 
   1250 bool ValidateTexCoord1fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
   1251 {
   1252    return true;
   1253 }
   1254 
   1255 bool ValidateTexCoord1i(const Context *, angle::EntryPoint entryPoint, GLint s)
   1256 {
   1257    return true;
   1258 }
   1259 
   1260 bool ValidateTexCoord1iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
   1261 {
   1262    return true;
   1263 }
   1264 
   1265 bool ValidateTexCoord1s(const Context *, angle::EntryPoint entryPoint, GLshort s)
   1266 {
   1267    return true;
   1268 }
   1269 
   1270 bool ValidateTexCoord1sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
   1271 {
   1272    return true;
   1273 }
   1274 
   1275 bool ValidateTexCoord2d(const Context *, angle::EntryPoint entryPoint, GLdouble s, GLdouble t)
   1276 {
   1277    return true;
   1278 }
   1279 
   1280 bool ValidateTexCoord2dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
   1281 {
   1282    return true;
   1283 }
   1284 
   1285 bool ValidateTexCoord2f(const Context *, angle::EntryPoint entryPoint, GLfloat s, GLfloat t)
   1286 {
   1287    return true;
   1288 }
   1289 
   1290 bool ValidateTexCoord2fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
   1291 {
   1292    return true;
   1293 }
   1294 
   1295 bool ValidateTexCoord2i(const Context *, angle::EntryPoint entryPoint, GLint s, GLint t)
   1296 {
   1297    return true;
   1298 }
   1299 
   1300 bool ValidateTexCoord2iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
   1301 {
   1302    return true;
   1303 }
   1304 
   1305 bool ValidateTexCoord2s(const Context *, angle::EntryPoint entryPoint, GLshort s, GLshort t)
   1306 {
   1307    return true;
   1308 }
   1309 
   1310 bool ValidateTexCoord2sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
   1311 {
   1312    return true;
   1313 }
   1314 
   1315 bool ValidateTexCoord3d(const Context *,
   1316                        angle::EntryPoint entryPoint,
   1317                        GLdouble s,
   1318                        GLdouble t,
   1319                        GLdouble r)
   1320 {
   1321    return true;
   1322 }
   1323 
   1324 bool ValidateTexCoord3dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
   1325 {
   1326    return true;
   1327 }
   1328 
   1329 bool ValidateTexCoord3f(const Context *,
   1330                        angle::EntryPoint entryPoint,
   1331                        GLfloat s,
   1332                        GLfloat t,
   1333                        GLfloat r)
   1334 {
   1335    return true;
   1336 }
   1337 
   1338 bool ValidateTexCoord3fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
   1339 {
   1340    return true;
   1341 }
   1342 
   1343 bool ValidateTexCoord3i(const Context *, angle::EntryPoint entryPoint, GLint s, GLint t, GLint r)
   1344 {
   1345    return true;
   1346 }
   1347 
   1348 bool ValidateTexCoord3iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
   1349 {
   1350    return true;
   1351 }
   1352 
   1353 bool ValidateTexCoord3s(const Context *,
   1354                        angle::EntryPoint entryPoint,
   1355                        GLshort s,
   1356                        GLshort t,
   1357                        GLshort r)
   1358 {
   1359    return true;
   1360 }
   1361 
   1362 bool ValidateTexCoord3sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
   1363 {
   1364    return true;
   1365 }
   1366 
   1367 bool ValidateTexCoord4d(const Context *,
   1368                        angle::EntryPoint entryPoint,
   1369                        GLdouble s,
   1370                        GLdouble t,
   1371                        GLdouble r,
   1372                        GLdouble q)
   1373 {
   1374    return true;
   1375 }
   1376 
   1377 bool ValidateTexCoord4dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
   1378 {
   1379    return true;
   1380 }
   1381 
   1382 bool ValidateTexCoord4f(const Context *,
   1383                        angle::EntryPoint entryPoint,
   1384                        GLfloat s,
   1385                        GLfloat t,
   1386                        GLfloat r,
   1387                        GLfloat q)
   1388 {
   1389    return true;
   1390 }
   1391 
   1392 bool ValidateTexCoord4fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
   1393 {
   1394    return true;
   1395 }
   1396 
   1397 bool ValidateTexCoord4i(const Context *,
   1398                        angle::EntryPoint entryPoint,
   1399                        GLint s,
   1400                        GLint t,
   1401                        GLint r,
   1402                        GLint q)
   1403 {
   1404    return true;
   1405 }
   1406 
   1407 bool ValidateTexCoord4iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
   1408 {
   1409    return true;
   1410 }
   1411 
   1412 bool ValidateTexCoord4s(const Context *,
   1413                        angle::EntryPoint entryPoint,
   1414                        GLshort s,
   1415                        GLshort t,
   1416                        GLshort r,
   1417                        GLshort q)
   1418 {
   1419    return true;
   1420 }
   1421 
   1422 bool ValidateTexCoord4sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
   1423 {
   1424    return true;
   1425 }
   1426 
   1427 bool ValidateTexGend(const Context *,
   1428                     angle::EntryPoint entryPoint,
   1429                     GLenum coord,
   1430                     GLenum pname,
   1431                     GLdouble param)
   1432 {
   1433    return true;
   1434 }
   1435 
   1436 bool ValidateTexGendv(const Context *,
   1437                      angle::EntryPoint entryPoint,
   1438                      GLenum coord,
   1439                      GLenum pname,
   1440                      const GLdouble *params)
   1441 {
   1442    return true;
   1443 }
   1444 
   1445 bool ValidateTexGenf(const Context *,
   1446                     angle::EntryPoint entryPoint,
   1447                     GLenum coord,
   1448                     GLenum pname,
   1449                     GLfloat param)
   1450 {
   1451    return true;
   1452 }
   1453 bool ValidateTexGenfv(const Context *,
   1454                      angle::EntryPoint entryPoint,
   1455                      GLenum coord,
   1456                      GLenum pname,
   1457                      const GLfloat *params)
   1458 {
   1459    return true;
   1460 }
   1461 
   1462 bool ValidateTexGeni(const Context *,
   1463                     angle::EntryPoint entryPoint,
   1464                     GLenum coord,
   1465                     GLenum pname,
   1466                     GLint param)
   1467 {
   1468    return true;
   1469 }
   1470 
   1471 bool ValidateTexGeniv(const Context *,
   1472                      angle::EntryPoint entryPoint,
   1473                      GLenum coord,
   1474                      GLenum pname,
   1475                      const GLint *params)
   1476 {
   1477    return true;
   1478 }
   1479 
   1480 bool ValidateTexImage1D(const Context *,
   1481                        angle::EntryPoint entryPoint,
   1482                        GLenum target,
   1483                        GLint level,
   1484                        GLint internalformat,
   1485                        GLsizei width,
   1486                        GLint border,
   1487                        GLenum format,
   1488                        GLenum type,
   1489                        const void *pixels)
   1490 {
   1491    return true;
   1492 }
   1493 
   1494 bool ValidateTranslated(const Context *,
   1495                        angle::EntryPoint entryPoint,
   1496                        GLdouble x,
   1497                        GLdouble y,
   1498                        GLdouble z)
   1499 {
   1500    return true;
   1501 }
   1502 
   1503 bool ValidateVertex2d(const Context *, angle::EntryPoint entryPoint, GLdouble x, GLdouble y)
   1504 {
   1505    return true;
   1506 }
   1507 
   1508 bool ValidateVertex2dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
   1509 {
   1510    return true;
   1511 }
   1512 
   1513 bool ValidateVertex2f(const Context *, angle::EntryPoint entryPoint, GLfloat x, GLfloat y)
   1514 {
   1515    return true;
   1516 }
   1517 
   1518 bool ValidateVertex2fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
   1519 {
   1520    return true;
   1521 }
   1522 
   1523 bool ValidateVertex2i(const Context *, angle::EntryPoint entryPoint, GLint x, GLint y)
   1524 {
   1525    return true;
   1526 }
   1527 
   1528 bool ValidateVertex2iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
   1529 {
   1530    return true;
   1531 }
   1532 
   1533 bool ValidateVertex2s(const Context *, angle::EntryPoint entryPoint, GLshort x, GLshort y)
   1534 {
   1535    return true;
   1536 }
   1537 
   1538 bool ValidateVertex2sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
   1539 {
   1540    return true;
   1541 }
   1542 
   1543 bool ValidateVertex3d(const Context *,
   1544                      angle::EntryPoint entryPoint,
   1545                      GLdouble x,
   1546                      GLdouble y,
   1547                      GLdouble z)
   1548 {
   1549    return true;
   1550 }
   1551 
   1552 bool ValidateVertex3dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
   1553 {
   1554    return true;
   1555 }
   1556 
   1557 bool ValidateVertex3f(const Context *,
   1558                      angle::EntryPoint entryPoint,
   1559                      GLfloat x,
   1560                      GLfloat y,
   1561                      GLfloat z)
   1562 {
   1563    return true;
   1564 }
   1565 
   1566 bool ValidateVertex3fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
   1567 {
   1568    return true;
   1569 }
   1570 
   1571 bool ValidateVertex3i(const Context *, angle::EntryPoint entryPoint, GLint x, GLint y, GLint z)
   1572 {
   1573    return true;
   1574 }
   1575 
   1576 bool ValidateVertex3iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
   1577 {
   1578    return true;
   1579 }
   1580 
   1581 bool ValidateVertex3s(const Context *,
   1582                      angle::EntryPoint entryPoint,
   1583                      GLshort x,
   1584                      GLshort y,
   1585                      GLshort z)
   1586 {
   1587    return true;
   1588 }
   1589 
   1590 bool ValidateVertex3sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
   1591 {
   1592    return true;
   1593 }
   1594 
   1595 bool ValidateVertex4d(const Context *,
   1596                      angle::EntryPoint entryPoint,
   1597                      GLdouble x,
   1598                      GLdouble y,
   1599                      GLdouble z,
   1600                      GLdouble w)
   1601 {
   1602    return true;
   1603 }
   1604 
   1605 bool ValidateVertex4dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
   1606 {
   1607    return true;
   1608 }
   1609 
   1610 bool ValidateVertex4f(const Context *,
   1611                      angle::EntryPoint entryPoint,
   1612                      GLfloat x,
   1613                      GLfloat y,
   1614                      GLfloat z,
   1615                      GLfloat w)
   1616 {
   1617    return true;
   1618 }
   1619 
   1620 bool ValidateVertex4fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
   1621 {
   1622    return true;
   1623 }
   1624 
   1625 bool ValidateVertex4i(const Context *,
   1626                      angle::EntryPoint entryPoint,
   1627                      GLint x,
   1628                      GLint y,
   1629                      GLint z,
   1630                      GLint w)
   1631 {
   1632    return true;
   1633 }
   1634 
   1635 bool ValidateVertex4iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
   1636 {
   1637    return true;
   1638 }
   1639 
   1640 bool ValidateVertex4s(const Context *,
   1641                      angle::EntryPoint entryPoint,
   1642                      GLshort x,
   1643                      GLshort y,
   1644                      GLshort z,
   1645                      GLshort w)
   1646 {
   1647    return true;
   1648 }
   1649 
   1650 bool ValidateVertex4sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
   1651 {
   1652    return true;
   1653 }
   1654 
   1655 bool ValidateAreTexturesResident(const Context *context,
   1656                                 angle::EntryPoint entryPoint,
   1657                                 GLsizei n,
   1658                                 const GLuint *textures,
   1659                                 const GLboolean *residences)
   1660 {
   1661    return true;
   1662 }
   1663 
   1664 bool ValidateArrayElement(const Context *context, angle::EntryPoint entryPoint, GLint i)
   1665 {
   1666    return true;
   1667 }
   1668 
   1669 bool ValidateCopyTexImage1D(const Context *context,
   1670                            angle::EntryPoint entryPoint,
   1671                            GLenum target,
   1672                            GLint level,
   1673                            GLenum internalformat,
   1674                            GLint x,
   1675                            GLint y,
   1676                            GLsizei width,
   1677                            GLint border)
   1678 {
   1679    return true;
   1680 }
   1681 
   1682 bool ValidateCopyTexSubImage1D(const Context *context,
   1683                               angle::EntryPoint entryPoint,
   1684                               GLenum target,
   1685                               GLint level,
   1686                               GLint xoffset,
   1687                               GLint x,
   1688                               GLint y,
   1689                               GLsizei width)
   1690 {
   1691    return true;
   1692 }
   1693 
   1694 bool ValidateEdgeFlagPointer(const Context *context,
   1695                             angle::EntryPoint entryPoint,
   1696                             GLsizei stride,
   1697                             const void *pointer)
   1698 {
   1699    return true;
   1700 }
   1701 
   1702 bool ValidateIndexPointer(const Context *context,
   1703                          angle::EntryPoint entryPoint,
   1704                          GLenum type,
   1705                          GLsizei stride,
   1706                          const void *pointer)
   1707 {
   1708    return true;
   1709 }
   1710 
   1711 bool ValidateIndexub(const Context *context, angle::EntryPoint entryPoint, GLubyte c)
   1712 {
   1713    return true;
   1714 }
   1715 
   1716 bool ValidateIndexubv(const Context *context, angle::EntryPoint entryPoint, const GLubyte *c)
   1717 {
   1718    return true;
   1719 }
   1720 
   1721 bool ValidateInterleavedArrays(const Context *context,
   1722                               angle::EntryPoint entryPoint,
   1723                               GLenum format,
   1724                               GLsizei stride,
   1725                               const void *pointer)
   1726 {
   1727    return true;
   1728 }
   1729 
   1730 bool ValidatePopClientAttrib(const Context *context, angle::EntryPoint entryPoint)
   1731 {
   1732    return true;
   1733 }
   1734 
   1735 bool ValidatePrioritizeTextures(const Context *context,
   1736                                angle::EntryPoint entryPoint,
   1737                                GLsizei n,
   1738                                const GLuint *textures,
   1739                                const GLfloat *priorities)
   1740 {
   1741    return true;
   1742 }
   1743 
   1744 bool ValidatePushClientAttrib(const Context *context, angle::EntryPoint entryPoint, GLbitfield mask)
   1745 {
   1746    return true;
   1747 }
   1748 
   1749 bool ValidateTexSubImage1D(const Context *context,
   1750                           angle::EntryPoint entryPoint,
   1751                           GLenum target,
   1752                           GLint level,
   1753                           GLint xoffset,
   1754                           GLsizei width,
   1755                           GLenum format,
   1756                           GLenum type,
   1757                           const void *pixels)
   1758 {
   1759    return true;
   1760 }
   1761 
   1762 bool ValidateCompressedTexImage1D(const Context *context,
   1763                                  angle::EntryPoint entryPoint,
   1764                                  GLenum target,
   1765                                  GLint level,
   1766                                  GLenum internalformat,
   1767                                  GLsizei width,
   1768                                  GLint border,
   1769                                  GLsizei imageSize,
   1770                                  const void *data)
   1771 {
   1772    return true;
   1773 }
   1774 
   1775 bool ValidateCompressedTexSubImage1D(const Context *context,
   1776                                     angle::EntryPoint entryPoint,
   1777                                     GLenum target,
   1778                                     GLint level,
   1779                                     GLint xoffset,
   1780                                     GLsizei width,
   1781                                     GLenum format,
   1782                                     GLsizei imageSize,
   1783                                     const void *data)
   1784 {
   1785    return true;
   1786 }
   1787 
   1788 bool ValidateGetCompressedTexImage(const Context *context,
   1789                                   angle::EntryPoint entryPoint,
   1790                                   TextureTarget targetPacked,
   1791                                   GLint level,
   1792                                   const void *img)
   1793 {
   1794    return true;
   1795 }
   1796 
   1797 bool ValidateLoadTransposeMatrixd(const Context *context,
   1798                                  angle::EntryPoint entryPoint,
   1799                                  const GLdouble *m)
   1800 {
   1801    return true;
   1802 }
   1803 
   1804 bool ValidateLoadTransposeMatrixf(const Context *context,
   1805                                  angle::EntryPoint entryPoint,
   1806                                  const GLfloat *m)
   1807 {
   1808    return true;
   1809 }
   1810 
   1811 bool ValidateMultTransposeMatrixd(const Context *context,
   1812                                  angle::EntryPoint entryPoint,
   1813                                  const GLdouble *m)
   1814 {
   1815    return true;
   1816 }
   1817 
   1818 bool ValidateMultTransposeMatrixf(const Context *context,
   1819                                  angle::EntryPoint entryPoint,
   1820                                  const GLfloat *m)
   1821 {
   1822    return true;
   1823 }
   1824 
   1825 bool ValidateMultiTexCoord1d(const Context *context,
   1826                             angle::EntryPoint entryPoint,
   1827                             GLenum target,
   1828                             GLdouble s)
   1829 {
   1830    return true;
   1831 }
   1832 
   1833 bool ValidateMultiTexCoord1dv(const Context *context,
   1834                              angle::EntryPoint entryPoint,
   1835                              GLenum target,
   1836                              const GLdouble *v)
   1837 {
   1838    return true;
   1839 }
   1840 
   1841 bool ValidateMultiTexCoord1f(const Context *context,
   1842                             angle::EntryPoint entryPoint,
   1843                             GLenum target,
   1844                             GLfloat s)
   1845 {
   1846    return true;
   1847 }
   1848 
   1849 bool ValidateMultiTexCoord1fv(const Context *context,
   1850                              angle::EntryPoint entryPoint,
   1851                              GLenum target,
   1852                              const GLfloat *v)
   1853 {
   1854    return true;
   1855 }
   1856 
   1857 bool ValidateMultiTexCoord1i(const Context *context,
   1858                             angle::EntryPoint entryPoint,
   1859                             GLenum target,
   1860                             GLint s)
   1861 {
   1862    return true;
   1863 }
   1864 
   1865 bool ValidateMultiTexCoord1iv(const Context *context,
   1866                              angle::EntryPoint entryPoint,
   1867                              GLenum target,
   1868                              const GLint *v)
   1869 {
   1870    return true;
   1871 }
   1872 
   1873 bool ValidateMultiTexCoord1s(const Context *context,
   1874                             angle::EntryPoint entryPoint,
   1875                             GLenum target,
   1876                             GLshort s)
   1877 {
   1878    return true;
   1879 }
   1880 
   1881 bool ValidateMultiTexCoord1sv(const Context *context,
   1882                              angle::EntryPoint entryPoint,
   1883                              GLenum target,
   1884                              const GLshort *v)
   1885 {
   1886    return true;
   1887 }
   1888 
   1889 bool ValidateMultiTexCoord2d(const Context *context,
   1890                             angle::EntryPoint entryPoint,
   1891                             GLenum target,
   1892                             GLdouble s,
   1893                             GLdouble t)
   1894 {
   1895    return true;
   1896 }
   1897 
   1898 bool ValidateMultiTexCoord2dv(const Context *context,
   1899                              angle::EntryPoint entryPoint,
   1900                              GLenum target,
   1901                              const GLdouble *v)
   1902 {
   1903    return true;
   1904 }
   1905 
   1906 bool ValidateMultiTexCoord2f(const Context *context,
   1907                             angle::EntryPoint entryPoint,
   1908                             GLenum target,
   1909                             GLfloat s,
   1910                             GLfloat t)
   1911 {
   1912    return true;
   1913 }
   1914 
   1915 bool ValidateMultiTexCoord2fv(const Context *context,
   1916                              angle::EntryPoint entryPoint,
   1917                              GLenum target,
   1918                              const GLfloat *v)
   1919 {
   1920    return true;
   1921 }
   1922 
   1923 bool ValidateMultiTexCoord2i(const Context *context,
   1924                             angle::EntryPoint entryPoint,
   1925                             GLenum target,
   1926                             GLint s,
   1927                             GLint t)
   1928 {
   1929    return true;
   1930 }
   1931 
   1932 bool ValidateMultiTexCoord2iv(const Context *context,
   1933                              angle::EntryPoint entryPoint,
   1934                              GLenum target,
   1935                              const GLint *v)
   1936 {
   1937    return true;
   1938 }
   1939 
   1940 bool ValidateMultiTexCoord2s(const Context *context,
   1941                             angle::EntryPoint entryPoint,
   1942                             GLenum target,
   1943                             GLshort s,
   1944                             GLshort t)
   1945 {
   1946    return true;
   1947 }
   1948 
   1949 bool ValidateMultiTexCoord2sv(const Context *context,
   1950                              angle::EntryPoint entryPoint,
   1951                              GLenum target,
   1952                              const GLshort *v)
   1953 {
   1954    return true;
   1955 }
   1956 
   1957 bool ValidateMultiTexCoord3d(const Context *context,
   1958                             angle::EntryPoint entryPoint,
   1959                             GLenum target,
   1960                             GLdouble s,
   1961                             GLdouble t,
   1962                             GLdouble r)
   1963 {
   1964    return true;
   1965 }
   1966 
   1967 bool ValidateMultiTexCoord3dv(const Context *context,
   1968                              angle::EntryPoint entryPoint,
   1969                              GLenum target,
   1970                              const GLdouble *v)
   1971 {
   1972    return true;
   1973 }
   1974 
   1975 bool ValidateMultiTexCoord3f(const Context *context,
   1976                             angle::EntryPoint entryPoint,
   1977                             GLenum target,
   1978                             GLfloat s,
   1979                             GLfloat t,
   1980                             GLfloat r)
   1981 {
   1982    return true;
   1983 }
   1984 
   1985 bool ValidateMultiTexCoord3fv(const Context *context,
   1986                              angle::EntryPoint entryPoint,
   1987                              GLenum target,
   1988                              const GLfloat *v)
   1989 {
   1990    return true;
   1991 }
   1992 
   1993 bool ValidateMultiTexCoord3i(const Context *context,
   1994                             angle::EntryPoint entryPoint,
   1995                             GLenum target,
   1996                             GLint s,
   1997                             GLint t,
   1998                             GLint r)
   1999 {
   2000    return true;
   2001 }
   2002 
   2003 bool ValidateMultiTexCoord3iv(const Context *context,
   2004                              angle::EntryPoint entryPoint,
   2005                              GLenum target,
   2006                              const GLint *v)
   2007 {
   2008    return true;
   2009 }
   2010 
   2011 bool ValidateMultiTexCoord3s(const Context *context,
   2012                             angle::EntryPoint entryPoint,
   2013                             GLenum target,
   2014                             GLshort s,
   2015                             GLshort t,
   2016                             GLshort r)
   2017 {
   2018    return true;
   2019 }
   2020 
   2021 bool ValidateMultiTexCoord3sv(const Context *context,
   2022                              angle::EntryPoint entryPoint,
   2023                              GLenum target,
   2024                              const GLshort *v)
   2025 {
   2026    return true;
   2027 }
   2028 
   2029 bool ValidateMultiTexCoord4d(const Context *context,
   2030                             angle::EntryPoint entryPoint,
   2031                             GLenum target,
   2032                             GLdouble s,
   2033                             GLdouble t,
   2034                             GLdouble r,
   2035                             GLdouble q)
   2036 {
   2037    return true;
   2038 }
   2039 
   2040 bool ValidateMultiTexCoord4dv(const Context *context,
   2041                              angle::EntryPoint entryPoint,
   2042                              GLenum target,
   2043                              const GLdouble *v)
   2044 {
   2045    return true;
   2046 }
   2047 
   2048 bool ValidateMultiTexCoord4fv(const Context *context,
   2049                              angle::EntryPoint entryPoint,
   2050                              GLenum target,
   2051                              const GLfloat *v)
   2052 {
   2053    return true;
   2054 }
   2055 
   2056 bool ValidateMultiTexCoord4i(const Context *context,
   2057                             angle::EntryPoint entryPoint,
   2058                             GLenum target,
   2059                             GLint s,
   2060                             GLint t,
   2061                             GLint r,
   2062                             GLint q)
   2063 {
   2064    return true;
   2065 }
   2066 
   2067 bool ValidateMultiTexCoord4iv(const Context *context,
   2068                              angle::EntryPoint entryPoint,
   2069                              GLenum target,
   2070                              const GLint *v)
   2071 {
   2072    return true;
   2073 }
   2074 
   2075 bool ValidateMultiTexCoord4s(const Context *context,
   2076                             angle::EntryPoint entryPoint,
   2077                             GLenum target,
   2078                             GLshort s,
   2079                             GLshort t,
   2080                             GLshort r,
   2081                             GLshort q)
   2082 {
   2083    return true;
   2084 }
   2085 
   2086 bool ValidateMultiTexCoord4sv(const Context *context,
   2087                              angle::EntryPoint entryPoint,
   2088                              GLenum target,
   2089                              const GLshort *v)
   2090 {
   2091    return true;
   2092 }
   2093 
   2094 bool ValidateFogCoordPointer(const Context *context,
   2095                             angle::EntryPoint entryPoint,
   2096                             GLenum type,
   2097                             GLsizei stride,
   2098                             const void *pointer)
   2099 {
   2100    return true;
   2101 }
   2102 
   2103 bool ValidateFogCoordd(const Context *context, angle::EntryPoint entryPoint, GLdouble coord)
   2104 {
   2105    return true;
   2106 }
   2107 
   2108 bool ValidateFogCoorddv(const Context *context, angle::EntryPoint entryPoint, const GLdouble *coord)
   2109 {
   2110    return true;
   2111 }
   2112 
   2113 bool ValidateFogCoordf(const Context *context, angle::EntryPoint entryPoint, GLfloat coord)
   2114 {
   2115    return true;
   2116 }
   2117 
   2118 bool ValidateFogCoordfv(const Context *context, angle::EntryPoint entryPoint, const GLfloat *coord)
   2119 {
   2120    return true;
   2121 }
   2122 
   2123 bool ValidateMultiDrawArrays(const Context *context,
   2124                             angle::EntryPoint entryPoint,
   2125                             PrimitiveMode modePacked,
   2126                             const GLint *first,
   2127                             const GLsizei *count,
   2128                             GLsizei drawcount)
   2129 {
   2130    return true;
   2131 }
   2132 
   2133 bool ValidateMultiDrawElements(const Context *context,
   2134                               angle::EntryPoint entryPoint,
   2135                               PrimitiveMode modePacked,
   2136                               const GLsizei *count,
   2137                               DrawElementsType typePacked,
   2138                               const void *const *indices,
   2139                               GLsizei drawcount)
   2140 {
   2141    return true;
   2142 }
   2143 
   2144 bool ValidatePointParameteri(const Context *context,
   2145                             angle::EntryPoint entryPoint,
   2146                             GLenum pname,
   2147                             GLint param)
   2148 {
   2149    return true;
   2150 }
   2151 
   2152 bool ValidatePointParameteriv(const Context *context,
   2153                              angle::EntryPoint entryPoint,
   2154                              GLenum pname,
   2155                              const GLint *params)
   2156 {
   2157    return true;
   2158 }
   2159 
   2160 bool ValidateSecondaryColor3b(const Context *context,
   2161                              angle::EntryPoint entryPoint,
   2162                              GLbyte red,
   2163                              GLbyte green,
   2164                              GLbyte blue)
   2165 {
   2166    return true;
   2167 }
   2168 
   2169 bool ValidateSecondaryColor3bv(const Context *context,
   2170                               angle::EntryPoint entryPoint,
   2171                               const GLbyte *v)
   2172 {
   2173    return true;
   2174 }
   2175 
   2176 bool ValidateSecondaryColor3d(const Context *context,
   2177                              angle::EntryPoint entryPoint,
   2178                              GLdouble red,
   2179                              GLdouble green,
   2180                              GLdouble blue)
   2181 {
   2182    return true;
   2183 }
   2184 
   2185 bool ValidateSecondaryColor3dv(const Context *context,
   2186                               angle::EntryPoint entryPoint,
   2187                               const GLdouble *v)
   2188 {
   2189    return true;
   2190 }
   2191 
   2192 bool ValidateSecondaryColor3f(const Context *context,
   2193                              angle::EntryPoint entryPoint,
   2194                              GLfloat red,
   2195                              GLfloat green,
   2196                              GLfloat blue)
   2197 {
   2198    return true;
   2199 }
   2200 
   2201 bool ValidateSecondaryColor3fv(const Context *context,
   2202                               angle::EntryPoint entryPoint,
   2203                               const GLfloat *v)
   2204 {
   2205    return true;
   2206 }
   2207 
   2208 bool ValidateSecondaryColor3i(const Context *context,
   2209                              angle::EntryPoint entryPoint,
   2210                              GLint red,
   2211                              GLint green,
   2212                              GLint blue)
   2213 {
   2214    return true;
   2215 }
   2216 
   2217 bool ValidateSecondaryColor3iv(const Context *context, angle::EntryPoint entryPoint, const GLint *v)
   2218 {
   2219    return true;
   2220 }
   2221 
   2222 bool ValidateSecondaryColor3s(const Context *context,
   2223                              angle::EntryPoint entryPoint,
   2224                              GLshort red,
   2225                              GLshort green,
   2226                              GLshort blue)
   2227 {
   2228    return true;
   2229 }
   2230 
   2231 bool ValidateSecondaryColor3sv(const Context *context,
   2232                               angle::EntryPoint entryPoint,
   2233                               const GLshort *v)
   2234 {
   2235    return true;
   2236 }
   2237 
   2238 bool ValidateSecondaryColor3ub(const Context *context,
   2239                               angle::EntryPoint entryPoint,
   2240                               GLubyte red,
   2241                               GLubyte green,
   2242                               GLubyte blue)
   2243 {
   2244    return true;
   2245 }
   2246 
   2247 bool ValidateSecondaryColor3ubv(const Context *context,
   2248                                angle::EntryPoint entryPoint,
   2249                                const GLubyte *v)
   2250 {
   2251    return true;
   2252 }
   2253 
   2254 bool ValidateSecondaryColor3ui(const Context *context,
   2255                               angle::EntryPoint entryPoint,
   2256                               GLuint red,
   2257                               GLuint green,
   2258                               GLuint blue)
   2259 {
   2260    return true;
   2261 }
   2262 
   2263 bool ValidateSecondaryColor3uiv(const Context *context,
   2264                                angle::EntryPoint entryPoint,
   2265                                const GLuint *v)
   2266 {
   2267    return true;
   2268 }
   2269 
   2270 bool ValidateSecondaryColor3us(const Context *context,
   2271                               angle::EntryPoint entryPoint,
   2272                               GLushort red,
   2273                               GLushort green,
   2274                               GLushort blue)
   2275 {
   2276    return true;
   2277 }
   2278 
   2279 bool ValidateSecondaryColor3usv(const Context *context,
   2280                                angle::EntryPoint entryPoint,
   2281                                const GLushort *v)
   2282 {
   2283    return true;
   2284 }
   2285 
   2286 bool ValidateSecondaryColorPointer(const Context *context,
   2287                                   angle::EntryPoint entryPoint,
   2288                                   GLint size,
   2289                                   GLenum type,
   2290                                   GLsizei stride,
   2291                                   const void *pointer)
   2292 {
   2293    return true;
   2294 }
   2295 
   2296 bool ValidateWindowPos2d(const Context *context,
   2297                         angle::EntryPoint entryPoint,
   2298                         GLdouble x,
   2299                         GLdouble y)
   2300 {
   2301    return true;
   2302 }
   2303 
   2304 bool ValidateWindowPos2dv(const Context *context, angle::EntryPoint entryPoint, const GLdouble *v)
   2305 {
   2306    return true;
   2307 }
   2308 
   2309 bool ValidateWindowPos2f(const Context *context, angle::EntryPoint entryPoint, GLfloat x, GLfloat y)
   2310 {
   2311    return true;
   2312 }
   2313 
   2314 bool ValidateWindowPos2fv(const Context *context, angle::EntryPoint entryPoint, const GLfloat *v)
   2315 {
   2316    return true;
   2317 }
   2318 
   2319 bool ValidateWindowPos2i(const Context *context, angle::EntryPoint entryPoint, GLint x, GLint y)
   2320 {
   2321    return true;
   2322 }
   2323 
   2324 bool ValidateWindowPos2iv(const Context *context, angle::EntryPoint entryPoint, const GLint *v)
   2325 {
   2326    return true;
   2327 }
   2328 
   2329 bool ValidateWindowPos2s(const Context *context, angle::EntryPoint entryPoint, GLshort x, GLshort y)
   2330 {
   2331    return true;
   2332 }
   2333 
   2334 bool ValidateWindowPos2sv(const Context *context, angle::EntryPoint entryPoint, const GLshort *v)
   2335 {
   2336    return true;
   2337 }
   2338 
   2339 bool ValidateWindowPos3d(const Context *context,
   2340                         angle::EntryPoint entryPoint,
   2341                         GLdouble x,
   2342                         GLdouble y,
   2343                         GLdouble z)
   2344 {
   2345    return true;
   2346 }
   2347 
   2348 bool ValidateWindowPos3dv(const Context *context, angle::EntryPoint entryPoint, const GLdouble *v)
   2349 {
   2350    return true;
   2351 }
   2352 
   2353 bool ValidateWindowPos3f(const Context *context,
   2354                         angle::EntryPoint entryPoint,
   2355                         GLfloat x,
   2356                         GLfloat y,
   2357                         GLfloat z)
   2358 {
   2359    return true;
   2360 }
   2361 
   2362 bool ValidateWindowPos3fv(const Context *context, angle::EntryPoint entryPoint, const GLfloat *v)
   2363 {
   2364    return true;
   2365 }
   2366 
   2367 bool ValidateWindowPos3i(const Context *context,
   2368                         angle::EntryPoint entryPoint,
   2369                         GLint x,
   2370                         GLint y,
   2371                         GLint z)
   2372 {
   2373    return true;
   2374 }
   2375 
   2376 bool ValidateWindowPos3iv(const Context *context, angle::EntryPoint entryPoint, const GLint *v)
   2377 {
   2378    return true;
   2379 }
   2380 
   2381 bool ValidateWindowPos3s(const Context *context,
   2382                         angle::EntryPoint entryPoint,
   2383                         GLshort x,
   2384                         GLshort y,
   2385                         GLshort z)
   2386 {
   2387    return true;
   2388 }
   2389 
   2390 bool ValidateWindowPos3sv(const Context *context, angle::EntryPoint entryPoint, const GLshort *v)
   2391 {
   2392    return true;
   2393 }
   2394 
   2395 bool ValidateGetBufferSubData(const Context *context,
   2396                              angle::EntryPoint entryPoint,
   2397                              GLenum target,
   2398                              GLintptr offset,
   2399                              GLsizeiptr size,
   2400                              const void *data)
   2401 {
   2402    return true;
   2403 }
   2404 
   2405 bool ValidateGetQueryObjectiv(const Context *context,
   2406                              angle::EntryPoint entryPoint,
   2407                              QueryID id,
   2408                              GLenum pname,
   2409                              const GLint *params)
   2410 {
   2411    return true;
   2412 }
   2413 
   2414 bool ValidateMapBuffer(const Context *context,
   2415                       angle::EntryPoint entryPoint,
   2416                       BufferBinding targetPacked,
   2417                       GLenum access)
   2418 {
   2419    return true;
   2420 }
   2421 }  // namespace gl
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE