tor-browser

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

Context_gl_1_autogen.h (34287B)


      1 // GENERATED FILE - DO NOT EDIT.
      2 // Generated by generate_entry_points.py using data from gl.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 // Context_gl_1_autogen.h: Creates a macro for interfaces in Context.
      9 
     10 #ifndef ANGLE_CONTEXT_GL_1_AUTOGEN_H_
     11 #define ANGLE_CONTEXT_GL_1_AUTOGEN_H_
     12 
     13 #define ANGLE_GL_1_CONTEXT_API                                                                     \
     14    void accum(GLenum op, GLfloat value);                                                          \
     15    void begin(GLenum mode);                                                                       \
     16    void bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove,        \
     17                GLfloat ymove, const GLubyte *bitmap);                                             \
     18    void callList(GLuint list);                                                                    \
     19    void callLists(GLsizei n, GLenum type, const void *lists);                                     \
     20    void clearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);                      \
     21    void clearDepth(GLdouble depth);                                                               \
     22    void clearIndex(GLfloat c);                                                                    \
     23    void clipPlane(GLenum plane, const GLdouble *equation);                                        \
     24    void color3b(GLbyte red, GLbyte green, GLbyte blue);                                           \
     25    void color3bv(const GLbyte *v);                                                                \
     26    void color3d(GLdouble red, GLdouble green, GLdouble blue);                                     \
     27    void color3dv(const GLdouble *v);                                                              \
     28    void color3f(GLfloat red, GLfloat green, GLfloat blue);                                        \
     29    void color3fv(const GLfloat *v);                                                               \
     30    void color3i(GLint red, GLint green, GLint blue);                                              \
     31    void color3iv(const GLint *v);                                                                 \
     32    void color3s(GLshort red, GLshort green, GLshort blue);                                        \
     33    void color3sv(const GLshort *v);                                                               \
     34    void color3ub(GLubyte red, GLubyte green, GLubyte blue);                                       \
     35    void color3ubv(const GLubyte *v);                                                              \
     36    void color3ui(GLuint red, GLuint green, GLuint blue);                                          \
     37    void color3uiv(const GLuint *v);                                                               \
     38    void color3us(GLushort red, GLushort green, GLushort blue);                                    \
     39    void color3usv(const GLushort *v);                                                             \
     40    void color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);                             \
     41    void color4bv(const GLbyte *v);                                                                \
     42    void color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);                     \
     43    void color4dv(const GLdouble *v);                                                              \
     44    void color4fv(const GLfloat *v);                                                               \
     45    void color4i(GLint red, GLint green, GLint blue, GLint alpha);                                 \
     46    void color4iv(const GLint *v);                                                                 \
     47    void color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);                         \
     48    void color4sv(const GLshort *v);                                                               \
     49    void color4ubv(const GLubyte *v);                                                              \
     50    void color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);                            \
     51    void color4uiv(const GLuint *v);                                                               \
     52    void color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);                    \
     53    void color4usv(const GLushort *v);                                                             \
     54    void colorMaterial(GLenum face, GLenum mode);                                                  \
     55    void copyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);                 \
     56    void deleteLists(GLuint list, GLsizei range);                                                  \
     57    void depthRange(GLdouble n, GLdouble f);                                                       \
     58    void drawBuffer(GLenum buf);                                                                   \
     59    void drawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type,                     \
     60                    const void *pixels);                                                           \
     61    void edgeFlag(GLboolean flag);                                                                 \
     62    void edgeFlagv(const GLboolean *flag);                                                         \
     63    void end();                                                                                    \
     64    void endList();                                                                                \
     65    void evalCoord1d(GLdouble u);                                                                  \
     66    void evalCoord1dv(const GLdouble *u);                                                          \
     67    void evalCoord1f(GLfloat u);                                                                   \
     68    void evalCoord1fv(const GLfloat *u);                                                           \
     69    void evalCoord2d(GLdouble u, GLdouble v);                                                      \
     70    void evalCoord2dv(const GLdouble *u);                                                          \
     71    void evalCoord2f(GLfloat u, GLfloat v);                                                        \
     72    void evalCoord2fv(const GLfloat *u);                                                           \
     73    void evalMesh1(GLenum mode, GLint i1, GLint i2);                                               \
     74    void evalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);                           \
     75    void evalPoint1(GLint i);                                                                      \
     76    void evalPoint2(GLint i, GLint j);                                                             \
     77    void feedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);                               \
     78    void fogi(GLenum pname, GLint param);                                                          \
     79    void fogiv(GLenum pname, const GLint *params);                                                 \
     80    void frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear,     \
     81                 GLdouble zFar);                                                                   \
     82    GLuint genLists(GLsizei range);                                                                \
     83    void getClipPlane(GLenum plane, GLdouble *equation);                                           \
     84    void getDoublev(GLenum pname, GLdouble *data);                                                 \
     85    void getLightiv(GLenum light, GLenum pname, GLint *params);                                    \
     86    void getMapdv(GLenum target, GLenum query, GLdouble *v);                                       \
     87    void getMapfv(GLenum target, GLenum query, GLfloat *v);                                        \
     88    void getMapiv(GLenum target, GLenum query, GLint *v);                                          \
     89    void getMaterialiv(GLenum face, GLenum pname, GLint *params);                                  \
     90    void getPixelMapfv(GLenum map, GLfloat *values);                                               \
     91    void getPixelMapuiv(GLenum map, GLuint *values);                                               \
     92    void getPixelMapusv(GLenum map, GLushort *values);                                             \
     93    void getPolygonStipple(GLubyte *mask);                                                         \
     94    void getTexGendv(GLenum coord, GLenum pname, GLdouble *params);                                \
     95    void indexMask(GLuint mask);                                                                   \
     96    void indexd(GLdouble c);                                                                       \
     97    void indexdv(const GLdouble *c);                                                               \
     98    void indexf(GLfloat c);                                                                        \
     99    void indexfv(const GLfloat *c);                                                                \
    100    void indexi(GLint c);                                                                          \
    101    void indexiv(const GLint *c);                                                                  \
    102    void indexs(GLshort c);                                                                        \
    103    void indexsv(const GLshort *c);                                                                \
    104    void initNames();                                                                              \
    105    GLboolean isList(GLuint list) const;                                                           \
    106    void lightModeli(GLenum pname, GLint param);                                                   \
    107    void lightModeliv(GLenum pname, const GLint *params);                                          \
    108    void lighti(GLenum light, GLenum pname, GLint param);                                          \
    109    void lightiv(GLenum light, GLenum pname, const GLint *params);                                 \
    110    void lineStipple(GLint factor, GLushort pattern);                                              \
    111    void listBase(GLuint base);                                                                    \
    112    void loadMatrixd(const GLdouble *m);                                                           \
    113    void loadName(GLuint name);                                                                    \
    114    void map1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order,                 \
    115               const GLdouble *points);                                                            \
    116    void map1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order,                   \
    117               const GLfloat *points);                                                             \
    118    void map2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1,  \
    119               GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);                  \
    120    void map2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1,     \
    121               GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);                    \
    122    void mapGrid1d(GLint un, GLdouble u1, GLdouble u2);                                            \
    123    void mapGrid1f(GLint un, GLfloat u1, GLfloat u2);                                              \
    124    void mapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);        \
    125    void mapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);            \
    126    void materiali(GLenum face, GLenum pname, GLint param);                                        \
    127    void materialiv(GLenum face, GLenum pname, const GLint *params);                               \
    128    void multMatrixd(const GLdouble *m);                                                           \
    129    void newList(GLuint list, GLenum mode);                                                        \
    130    void normal3b(GLbyte nx, GLbyte ny, GLbyte nz);                                                \
    131    void normal3bv(const GLbyte *v);                                                               \
    132    void normal3d(GLdouble nx, GLdouble ny, GLdouble nz);                                          \
    133    void normal3dv(const GLdouble *v);                                                             \
    134    void normal3fv(const GLfloat *v);                                                              \
    135    void normal3i(GLint nx, GLint ny, GLint nz);                                                   \
    136    void normal3iv(const GLint *v);                                                                \
    137    void normal3s(GLshort nx, GLshort ny, GLshort nz);                                             \
    138    void normal3sv(const GLshort *v);                                                              \
    139    void ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear,       \
    140               GLdouble zFar);                                                                     \
    141    void passThrough(GLfloat token);                                                               \
    142    void pixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values);                           \
    143    void pixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values);                           \
    144    void pixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values);                         \
    145    void pixelStoref(GLenum pname, GLfloat param);                                                 \
    146    void pixelTransferf(GLenum pname, GLfloat param);                                              \
    147    void pixelTransferi(GLenum pname, GLint param);                                                \
    148    void pixelZoom(GLfloat xfactor, GLfloat yfactor);                                              \
    149    void polygonMode(GLenum face, GLenum mode);                                                    \
    150    void polygonStipple(const GLubyte *mask);                                                      \
    151    void popAttrib();                                                                              \
    152    void popName();                                                                                \
    153    void pushAttrib(GLbitfield mask);                                                              \
    154    void pushName(GLuint name);                                                                    \
    155    void rasterPos2d(GLdouble x, GLdouble y);                                                      \
    156    void rasterPos2dv(const GLdouble *v);                                                          \
    157    void rasterPos2f(GLfloat x, GLfloat y);                                                        \
    158    void rasterPos2fv(const GLfloat *v);                                                           \
    159    void rasterPos2i(GLint x, GLint y);                                                            \
    160    void rasterPos2iv(const GLint *v);                                                             \
    161    void rasterPos2s(GLshort x, GLshort y);                                                        \
    162    void rasterPos2sv(const GLshort *v);                                                           \
    163    void rasterPos3d(GLdouble x, GLdouble y, GLdouble z);                                          \
    164    void rasterPos3dv(const GLdouble *v);                                                          \
    165    void rasterPos3f(GLfloat x, GLfloat y, GLfloat z);                                             \
    166    void rasterPos3fv(const GLfloat *v);                                                           \
    167    void rasterPos3i(GLint x, GLint y, GLint z);                                                   \
    168    void rasterPos3iv(const GLint *v);                                                             \
    169    void rasterPos3s(GLshort x, GLshort y, GLshort z);                                             \
    170    void rasterPos3sv(const GLshort *v);                                                           \
    171    void rasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);                              \
    172    void rasterPos4dv(const GLdouble *v);                                                          \
    173    void rasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);                                  \
    174    void rasterPos4fv(const GLfloat *v);                                                           \
    175    void rasterPos4i(GLint x, GLint y, GLint z, GLint w);                                          \
    176    void rasterPos4iv(const GLint *v);                                                             \
    177    void rasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);                                  \
    178    void rasterPos4sv(const GLshort *v);                                                           \
    179    void rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);                                \
    180    void rectdv(const GLdouble *v1, const GLdouble *v2);                                           \
    181    void rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);                                    \
    182    void rectfv(const GLfloat *v1, const GLfloat *v2);                                             \
    183    void recti(GLint x1, GLint y1, GLint x2, GLint y2);                                            \
    184    void rectiv(const GLint *v1, const GLint *v2);                                                 \
    185    void rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);                                    \
    186    void rectsv(const GLshort *v1, const GLshort *v2);                                             \
    187    GLint renderMode(GLenum mode);                                                                 \
    188    void rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);                              \
    189    void scaled(GLdouble x, GLdouble y, GLdouble z);                                               \
    190    void selectBuffer(GLsizei size, GLuint *buffer);                                               \
    191    void texCoord1d(GLdouble s);                                                                   \
    192    void texCoord1dv(const GLdouble *v);                                                           \
    193    void texCoord1f(GLfloat s);                                                                    \
    194    void texCoord1fv(const GLfloat *v);                                                            \
    195    void texCoord1i(GLint s);                                                                      \
    196    void texCoord1iv(const GLint *v);                                                              \
    197    void texCoord1s(GLshort s);                                                                    \
    198    void texCoord1sv(const GLshort *v);                                                            \
    199    void texCoord2d(GLdouble s, GLdouble t);                                                       \
    200    void texCoord2dv(const GLdouble *v);                                                           \
    201    void texCoord2f(GLfloat s, GLfloat t);                                                         \
    202    void texCoord2fv(const GLfloat *v);                                                            \
    203    void texCoord2i(GLint s, GLint t);                                                             \
    204    void texCoord2iv(const GLint *v);                                                              \
    205    void texCoord2s(GLshort s, GLshort t);                                                         \
    206    void texCoord2sv(const GLshort *v);                                                            \
    207    void texCoord3d(GLdouble s, GLdouble t, GLdouble r);                                           \
    208    void texCoord3dv(const GLdouble *v);                                                           \
    209    void texCoord3f(GLfloat s, GLfloat t, GLfloat r);                                              \
    210    void texCoord3fv(const GLfloat *v);                                                            \
    211    void texCoord3i(GLint s, GLint t, GLint r);                                                    \
    212    void texCoord3iv(const GLint *v);                                                              \
    213    void texCoord3s(GLshort s, GLshort t, GLshort r);                                              \
    214    void texCoord3sv(const GLshort *v);                                                            \
    215    void texCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);                               \
    216    void texCoord4dv(const GLdouble *v);                                                           \
    217    void texCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);                                   \
    218    void texCoord4fv(const GLfloat *v);                                                            \
    219    void texCoord4i(GLint s, GLint t, GLint r, GLint q);                                           \
    220    void texCoord4iv(const GLint *v);                                                              \
    221    void texCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);                                   \
    222    void texCoord4sv(const GLshort *v);                                                            \
    223    void texGend(GLenum coord, GLenum pname, GLdouble param);                                      \
    224    void texGendv(GLenum coord, GLenum pname, const GLdouble *params);                             \
    225    void texImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, \
    226                    GLenum format, GLenum type, const void *pixels);                               \
    227    void translated(GLdouble x, GLdouble y, GLdouble z);                                           \
    228    void vertex2d(GLdouble x, GLdouble y);                                                         \
    229    void vertex2dv(const GLdouble *v);                                                             \
    230    void vertex2f(GLfloat x, GLfloat y);                                                           \
    231    void vertex2fv(const GLfloat *v);                                                              \
    232    void vertex2i(GLint x, GLint y);                                                               \
    233    void vertex2iv(const GLint *v);                                                                \
    234    void vertex2s(GLshort x, GLshort y);                                                           \
    235    void vertex2sv(const GLshort *v);                                                              \
    236    void vertex3d(GLdouble x, GLdouble y, GLdouble z);                                             \
    237    void vertex3dv(const GLdouble *v);                                                             \
    238    void vertex3f(GLfloat x, GLfloat y, GLfloat z);                                                \
    239    void vertex3fv(const GLfloat *v);                                                              \
    240    void vertex3i(GLint x, GLint y, GLint z);                                                      \
    241    void vertex3iv(const GLint *v);                                                                \
    242    void vertex3s(GLshort x, GLshort y, GLshort z);                                                \
    243    void vertex3sv(const GLshort *v);                                                              \
    244    void vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);                                 \
    245    void vertex4dv(const GLdouble *v);                                                             \
    246    void vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);                                     \
    247    void vertex4fv(const GLfloat *v);                                                              \
    248    void vertex4i(GLint x, GLint y, GLint z, GLint w);                                             \
    249    void vertex4iv(const GLint *v);                                                                \
    250    void vertex4s(GLshort x, GLshort y, GLshort z, GLshort w);                                     \
    251    void vertex4sv(const GLshort *v);                                                              \
    252    GLboolean areTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);       \
    253    void arrayElement(GLint i);                                                                    \
    254    void copyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y,       \
    255                        GLsizei width, GLint border);                                              \
    256    void copyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y,            \
    257                           GLsizei width);                                                         \
    258    void edgeFlagPointer(GLsizei stride, const void *pointer);                                     \
    259    void indexPointer(GLenum type, GLsizei stride, const void *pointer);                           \
    260    void indexub(GLubyte c);                                                                       \
    261    void indexubv(const GLubyte *c);                                                               \
    262    void interleavedArrays(GLenum format, GLsizei stride, const void *pointer);                    \
    263    void popClientAttrib();                                                                        \
    264    void prioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);         \
    265    void pushClientAttrib(GLbitfield mask);                                                        \
    266    void texSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format,    \
    267                       GLenum type, const void *pixels);                                           \
    268    void compressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width,    \
    269                              GLint border, GLsizei imageSize, const void *data);                  \
    270    void compressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width,         \
    271                                 GLenum format, GLsizei imageSize, const void *data);              \
    272    void loadTransposeMatrixd(const GLdouble *m);                                                  \
    273    void loadTransposeMatrixf(const GLfloat *m);                                                   \
    274    void multTransposeMatrixd(const GLdouble *m);                                                  \
    275    void multTransposeMatrixf(const GLfloat *m);                                                   \
    276    void multiTexCoord1d(GLenum target, GLdouble s);                                               \
    277    void multiTexCoord1dv(GLenum target, const GLdouble *v);                                       \
    278    void multiTexCoord1f(GLenum target, GLfloat s);                                                \
    279    void multiTexCoord1fv(GLenum target, const GLfloat *v);                                        \
    280    void multiTexCoord1i(GLenum target, GLint s);                                                  \
    281    void multiTexCoord1iv(GLenum target, const GLint *v);                                          \
    282    void multiTexCoord1s(GLenum target, GLshort s);                                                \
    283    void multiTexCoord1sv(GLenum target, const GLshort *v);                                        \
    284    void multiTexCoord2d(GLenum target, GLdouble s, GLdouble t);                                   \
    285    void multiTexCoord2dv(GLenum target, const GLdouble *v);                                       \
    286    void multiTexCoord2f(GLenum target, GLfloat s, GLfloat t);                                     \
    287    void multiTexCoord2fv(GLenum target, const GLfloat *v);                                        \
    288    void multiTexCoord2i(GLenum target, GLint s, GLint t);                                         \
    289    void multiTexCoord2iv(GLenum target, const GLint *v);                                          \
    290    void multiTexCoord2s(GLenum target, GLshort s, GLshort t);                                     \
    291    void multiTexCoord2sv(GLenum target, const GLshort *v);                                        \
    292    void multiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);                       \
    293    void multiTexCoord3dv(GLenum target, const GLdouble *v);                                       \
    294    void multiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);                          \
    295    void multiTexCoord3fv(GLenum target, const GLfloat *v);                                        \
    296    void multiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);                                \
    297    void multiTexCoord3iv(GLenum target, const GLint *v);                                          \
    298    void multiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);                          \
    299    void multiTexCoord3sv(GLenum target, const GLshort *v);                                        \
    300    void multiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);           \
    301    void multiTexCoord4dv(GLenum target, const GLdouble *v);                                       \
    302    void multiTexCoord4fv(GLenum target, const GLfloat *v);                                        \
    303    void multiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);                       \
    304    void multiTexCoord4iv(GLenum target, const GLint *v);                                          \
    305    void multiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);               \
    306    void multiTexCoord4sv(GLenum target, const GLshort *v);                                        \
    307    void fogCoordPointer(GLenum type, GLsizei stride, const void *pointer);                        \
    308    void fogCoordd(GLdouble coord);                                                                \
    309    void fogCoorddv(const GLdouble *coord);                                                        \
    310    void fogCoordf(GLfloat coord);                                                                 \
    311    void fogCoordfv(const GLfloat *coord);                                                         \
    312    void pointParameteri(GLenum pname, GLint param);                                               \
    313    void pointParameteriv(GLenum pname, const GLint *params);                                      \
    314    void secondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);                                  \
    315    void secondaryColor3bv(const GLbyte *v);                                                       \
    316    void secondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);                            \
    317    void secondaryColor3dv(const GLdouble *v);                                                     \
    318    void secondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);                               \
    319    void secondaryColor3fv(const GLfloat *v);                                                      \
    320    void secondaryColor3i(GLint red, GLint green, GLint blue);                                     \
    321    void secondaryColor3iv(const GLint *v);                                                        \
    322    void secondaryColor3s(GLshort red, GLshort green, GLshort blue);                               \
    323    void secondaryColor3sv(const GLshort *v);                                                      \
    324    void secondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);                              \
    325    void secondaryColor3ubv(const GLubyte *v);                                                     \
    326    void secondaryColor3ui(GLuint red, GLuint green, GLuint blue);                                 \
    327    void secondaryColor3uiv(const GLuint *v);                                                      \
    328    void secondaryColor3us(GLushort red, GLushort green, GLushort blue);                           \
    329    void secondaryColor3usv(const GLushort *v);                                                    \
    330    void secondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);      \
    331    void windowPos2d(GLdouble x, GLdouble y);                                                      \
    332    void windowPos2dv(const GLdouble *v);                                                          \
    333    void windowPos2f(GLfloat x, GLfloat y);                                                        \
    334    void windowPos2fv(const GLfloat *v);                                                           \
    335    void windowPos2i(GLint x, GLint y);                                                            \
    336    void windowPos2iv(const GLint *v);                                                             \
    337    void windowPos2s(GLshort x, GLshort y);                                                        \
    338    void windowPos2sv(const GLshort *v);                                                           \
    339    void windowPos3d(GLdouble x, GLdouble y, GLdouble z);                                          \
    340    void windowPos3dv(const GLdouble *v);                                                          \
    341    void windowPos3f(GLfloat x, GLfloat y, GLfloat z);                                             \
    342    void windowPos3fv(const GLfloat *v);                                                           \
    343    void windowPos3i(GLint x, GLint y, GLint z);                                                   \
    344    void windowPos3iv(const GLint *v);                                                             \
    345    void windowPos3s(GLshort x, GLshort y, GLshort z);                                             \
    346    void windowPos3sv(const GLshort *v);                                                           \
    347    void getBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data);
    348 
    349 #endif  // ANGLE_CONTEXT_API_1_AUTOGEN_H_