Context_gl_1_autogen.h

// GENERATED FILE - DO NOT EDIT.

// Generated by generate_entry_points.py using data from gl.xml.

//

// Copyright 2020 The ANGLE Project Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

//

// Context_gl_1_autogen.h: Creates a macro for interfaces in Context.

#ifndef ANGLE_CONTEXT_GL_1_AUTOGEN_H_

#define ANGLE_CONTEXT_GL_1_AUTOGEN_H_

#define ANGLE_GL_1_CONTEXT_API                                                                     \

    void accum(GLenum op, GLfloat value);                                                          \

    void begin(GLenum mode);                                                                       \

    void bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove,        \

                GLfloat ymove, const GLubyte *bitmap);                                             \

    void callList(GLuint list);                                                                    \

    void callLists(GLsizei n, GLenum type, const void *lists);                                     \

    void clearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);                      \

    void clearDepth(GLdouble depth);                                                               \

    void clearIndex(GLfloat c);                                                                    \

    void clipPlane(GLenum plane, const GLdouble *equation);                                        \

    void color3b(GLbyte red, GLbyte green, GLbyte blue);                                           \

    void color3bv(const GLbyte *v);                                                                \

    void color3d(GLdouble red, GLdouble green, GLdouble blue);                                     \

    void color3dv(const GLdouble *v);                                                              \

    void color3f(GLfloat red, GLfloat green, GLfloat blue);                                        \

    void color3fv(const GLfloat *v);                                                               \

    void color3i(GLint red, GLint green, GLint blue);                                              \

    void color3iv(const GLint *v);                                                                 \

    void color3s(GLshort red, GLshort green, GLshort blue);                                        \

    void color3sv(const GLshort *v);                                                               \

    void color3ub(GLubyte red, GLubyte green, GLubyte blue);                                       \

    void color3ubv(const GLubyte *v);                                                              \

    void color3ui(GLuint red, GLuint green, GLuint blue);                                          \

    void color3uiv(const GLuint *v);                                                               \

    void color3us(GLushort red, GLushort green, GLushort blue);                                    \

    void color3usv(const GLushort *v);                                                             \

    void color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);                             \

    void color4bv(const GLbyte *v);                                                                \

    void color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);                     \

    void color4dv(const GLdouble *v);                                                              \

    void color4fv(const GLfloat *v);                                                               \

    void color4i(GLint red, GLint green, GLint blue, GLint alpha);                                 \

    void color4iv(const GLint *v);                                                                 \

    void color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);                         \

    void color4sv(const GLshort *v);                                                               \

    void color4ubv(const GLubyte *v);                                                              \

    void color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);                            \

    void color4uiv(const GLuint *v);                                                               \

    void color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);                    \

    void color4usv(const GLushort *v);                                                             \

    void colorMaterial(GLenum face, GLenum mode);                                                  \

    void copyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);                 \

    void deleteLists(GLuint list, GLsizei range);                                                  \

    void depthRange(GLdouble n, GLdouble f);                                                       \

    void drawBuffer(GLenum buf);                                                                   \

    void drawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type,                     \

                    const void *pixels);                                                           \

    void edgeFlag(GLboolean flag);                                                                 \

    void edgeFlagv(const GLboolean *flag);                                                         \

    void end();                                                                                    \

    void endList();                                                                                \

    void evalCoord1d(GLdouble u);                                                                  \

    void evalCoord1dv(const GLdouble *u);                                                          \

    void evalCoord1f(GLfloat u);                                                                   \

    void evalCoord1fv(const GLfloat *u);                                                           \

    void evalCoord2d(GLdouble u, GLdouble v);                                                      \

    void evalCoord2dv(const GLdouble *u);                                                          \

    void evalCoord2f(GLfloat u, GLfloat v);                                                        \

    void evalCoord2fv(const GLfloat *u);                                                           \

    void evalMesh1(GLenum mode, GLint i1, GLint i2);                                               \

    void evalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);                           \

    void evalPoint1(GLint i);                                                                      \

    void evalPoint2(GLint i, GLint j);                                                             \

    void feedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);                               \

    void fogi(GLenum pname, GLint param);                                                          \

    void fogiv(GLenum pname, const GLint *params);                                                 \

    void frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear,     \

                 GLdouble zFar);                                                                   \

    GLuint genLists(GLsizei range);                                                                \

    void getClipPlane(GLenum plane, GLdouble *equation);                                           \

    void getDoublev(GLenum pname, GLdouble *data);                                                 \

    void getLightiv(GLenum light, GLenum pname, GLint *params);                                    \

    void getMapdv(GLenum target, GLenum query, GLdouble *v);                                       \

    void getMapfv(GLenum target, GLenum query, GLfloat *v);                                        \

    void getMapiv(GLenum target, GLenum query, GLint *v);                                          \

    void getMaterialiv(GLenum face, GLenum pname, GLint *params);                                  \

    void getPixelMapfv(GLenum map, GLfloat *values);                                               \

    void getPixelMapuiv(GLenum map, GLuint *values);                                               \

    void getPixelMapusv(GLenum map, GLushort *values);                                             \

    void getPolygonStipple(GLubyte *mask);                                                         \

    void getTexGendv(GLenum coord, GLenum pname, GLdouble *params);                                \

    void indexMask(GLuint mask);                                                                   \

    void indexd(GLdouble c);                                                                       \

    void indexdv(const GLdouble *c);                                                               \

    void indexf(GLfloat c);                                                                        \

    void indexfv(const GLfloat *c);                                                                \

    void indexi(GLint c);                                                                          \

    void indexiv(const GLint *c);                                                                  \

    void indexs(GLshort c);                                                                        \

    void indexsv(const GLshort *c);                                                                \

    void initNames();                                                                              \

    GLboolean isList(GLuint list) const;                                                           \

    void lightModeli(GLenum pname, GLint param);                                                   \

    void lightModeliv(GLenum pname, const GLint *params);                                          \

    void lighti(GLenum light, GLenum pname, GLint param);                                          \

    void lightiv(GLenum light, GLenum pname, const GLint *params);                                 \

    void lineStipple(GLint factor, GLushort pattern);                                              \

    void listBase(GLuint base);                                                                    \

    void loadMatrixd(const GLdouble *m);                                                           \

    void loadName(GLuint name);                                                                    \

    void map1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order,                 \

               const GLdouble *points);                                                            \

    void map1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order,                   \

               const GLfloat *points);                                                             \

    void map2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1,  \

               GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);                  \

    void map2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1,     \

               GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);                    \

    void mapGrid1d(GLint un, GLdouble u1, GLdouble u2);                                            \

    void mapGrid1f(GLint un, GLfloat u1, GLfloat u2);                                              \

    void mapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);        \

    void mapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);            \

    void materiali(GLenum face, GLenum pname, GLint param);                                        \

    void materialiv(GLenum face, GLenum pname, const GLint *params);                               \

    void multMatrixd(const GLdouble *m);                                                           \

    void newList(GLuint list, GLenum mode);                                                        \

    void normal3b(GLbyte nx, GLbyte ny, GLbyte nz);                                                \

    void normal3bv(const GLbyte *v);                                                               \

    void normal3d(GLdouble nx, GLdouble ny, GLdouble nz);                                          \

    void normal3dv(const GLdouble *v);                                                             \

    void normal3fv(const GLfloat *v);                                                              \

    void normal3i(GLint nx, GLint ny, GLint nz);                                                   \

    void normal3iv(const GLint *v);                                                                \

    void normal3s(GLshort nx, GLshort ny, GLshort nz);                                             \

    void normal3sv(const GLshort *v);                                                              \

    void ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear,       \

               GLdouble zFar);                                                                     \

    void passThrough(GLfloat token);                                                               \

    void pixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values);                           \

    void pixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values);                           \

    void pixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values);                         \

    void pixelStoref(GLenum pname, GLfloat param);                                                 \

    void pixelTransferf(GLenum pname, GLfloat param);                                              \

    void pixelTransferi(GLenum pname, GLint param);                                                \

    void pixelZoom(GLfloat xfactor, GLfloat yfactor);                                              \

    void polygonMode(GLenum face, GLenum mode);                                                    \

    void polygonStipple(const GLubyte *mask);                                                      \

    void popAttrib();                                                                              \

    void popName();                                                                                \

    void pushAttrib(GLbitfield mask);                                                              \

    void pushName(GLuint name);                                                                    \

    void rasterPos2d(GLdouble x, GLdouble y);                                                      \

    void rasterPos2dv(const GLdouble *v);                                                          \

    void rasterPos2f(GLfloat x, GLfloat y);                                                        \

    void rasterPos2fv(const GLfloat *v);                                                           \

    void rasterPos2i(GLint x, GLint y);                                                            \

    void rasterPos2iv(const GLint *v);                                                             \

    void rasterPos2s(GLshort x, GLshort y);                                                        \

    void rasterPos2sv(const GLshort *v);                                                           \

    void rasterPos3d(GLdouble x, GLdouble y, GLdouble z);                                          \

    void rasterPos3dv(const GLdouble *v);                                                          \

    void rasterPos3f(GLfloat x, GLfloat y, GLfloat z);                                             \

    void rasterPos3fv(const GLfloat *v);                                                           \

    void rasterPos3i(GLint x, GLint y, GLint z);                                                   \

    void rasterPos3iv(const GLint *v);                                                             \

    void rasterPos3s(GLshort x, GLshort y, GLshort z);                                             \

    void rasterPos3sv(const GLshort *v);                                                           \

    void rasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);                              \

    void rasterPos4dv(const GLdouble *v);                                                          \

    void rasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);                                  \

    void rasterPos4fv(const GLfloat *v);                                                           \

    void rasterPos4i(GLint x, GLint y, GLint z, GLint w);                                          \

    void rasterPos4iv(const GLint *v);                                                             \

    void rasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);                                  \

    void rasterPos4sv(const GLshort *v);                                                           \

    void rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);                                \

    void rectdv(const GLdouble *v1, const GLdouble *v2);                                           \

    void rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);                                    \

    void rectfv(const GLfloat *v1, const GLfloat *v2);                                             \

    void recti(GLint x1, GLint y1, GLint x2, GLint y2);                                            \

    void rectiv(const GLint *v1, const GLint *v2);                                                 \

    void rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);                                    \

    void rectsv(const GLshort *v1, const GLshort *v2);                                             \

    GLint renderMode(GLenum mode);                                                                 \

    void rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);                              \

    void scaled(GLdouble x, GLdouble y, GLdouble z);                                               \

    void selectBuffer(GLsizei size, GLuint *buffer);                                               \

    void texCoord1d(GLdouble s);                                                                   \

    void texCoord1dv(const GLdouble *v);                                                           \

    void texCoord1f(GLfloat s);                                                                    \

    void texCoord1fv(const GLfloat *v);                                                            \

    void texCoord1i(GLint s);                                                                      \

    void texCoord1iv(const GLint *v);                                                              \

    void texCoord1s(GLshort s);                                                                    \

    void texCoord1sv(const GLshort *v);                                                            \

    void texCoord2d(GLdouble s, GLdouble t);                                                       \

    void texCoord2dv(const GLdouble *v);                                                           \

    void texCoord2f(GLfloat s, GLfloat t);                                                         \

    void texCoord2fv(const GLfloat *v);                                                            \

    void texCoord2i(GLint s, GLint t);                                                             \

    void texCoord2iv(const GLint *v);                                                              \

    void texCoord2s(GLshort s, GLshort t);                                                         \

    void texCoord2sv(const GLshort *v);                                                            \

    void texCoord3d(GLdouble s, GLdouble t, GLdouble r);                                           \

    void texCoord3dv(const GLdouble *v);                                                           \

    void texCoord3f(GLfloat s, GLfloat t, GLfloat r);                                              \

    void texCoord3fv(const GLfloat *v);                                                            \

    void texCoord3i(GLint s, GLint t, GLint r);                                                    \

    void texCoord3iv(const GLint *v);                                                              \

    void texCoord3s(GLshort s, GLshort t, GLshort r);                                              \

    void texCoord3sv(const GLshort *v);                                                            \

    void texCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);                               \

    void texCoord4dv(const GLdouble *v);                                                           \

    void texCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);                                   \

    void texCoord4fv(const GLfloat *v);                                                            \

    void texCoord4i(GLint s, GLint t, GLint r, GLint q);                                           \

    void texCoord4iv(const GLint *v);                                                              \

    void texCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);                                   \

    void texCoord4sv(const GLshort *v);                                                            \

    void texGend(GLenum coord, GLenum pname, GLdouble param);                                      \

    void texGendv(GLenum coord, GLenum pname, const GLdouble *params);                             \

    void texImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, \

                    GLenum format, GLenum type, const void *pixels);                               \

    void translated(GLdouble x, GLdouble y, GLdouble z);                                           \

    void vertex2d(GLdouble x, GLdouble y);                                                         \

    void vertex2dv(const GLdouble *v);                                                             \

    void vertex2f(GLfloat x, GLfloat y);                                                           \

    void vertex2fv(const GLfloat *v);                                                              \

    void vertex2i(GLint x, GLint y);                                                               \

    void vertex2iv(const GLint *v);                                                                \

    void vertex2s(GLshort x, GLshort y);                                                           \

    void vertex2sv(const GLshort *v);                                                              \

    void vertex3d(GLdouble x, GLdouble y, GLdouble z);                                             \

    void vertex3dv(const GLdouble *v);                                                             \

    void vertex3f(GLfloat x, GLfloat y, GLfloat z);                                                \

    void vertex3fv(const GLfloat *v);                                                              \

    void vertex3i(GLint x, GLint y, GLint z);                                                      \

    void vertex3iv(const GLint *v);                                                                \

    void vertex3s(GLshort x, GLshort y, GLshort z);                                                \

    void vertex3sv(const GLshort *v);                                                              \

    void vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);                                 \

    void vertex4dv(const GLdouble *v);                                                             \

    void vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);                                     \

    void vertex4fv(const GLfloat *v);                                                              \

    void vertex4i(GLint x, GLint y, GLint z, GLint w);                                             \

    void vertex4iv(const GLint *v);                                                                \

    void vertex4s(GLshort x, GLshort y, GLshort z, GLshort w);                                     \

    void vertex4sv(const GLshort *v);                                                              \

    GLboolean areTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);       \

    void arrayElement(GLint i);                                                                    \

    void copyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y,       \

                        GLsizei width, GLint border);                                              \

    void copyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y,            \

                           GLsizei width);                                                         \

    void edgeFlagPointer(GLsizei stride, const void *pointer);                                     \

    void indexPointer(GLenum type, GLsizei stride, const void *pointer);                           \

    void indexub(GLubyte c);                                                                       \

    void indexubv(const GLubyte *c);                                                               \

    void interleavedArrays(GLenum format, GLsizei stride, const void *pointer);                    \

    void popClientAttrib();                                                                        \

    void prioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);         \

    void pushClientAttrib(GLbitfield mask);                                                        \

    void texSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format,    \

                       GLenum type, const void *pixels);                                           \

    void compressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width,    \

                              GLint border, GLsizei imageSize, const void *data);                  \

    void compressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width,         \

                                 GLenum format, GLsizei imageSize, const void *data);              \

    void loadTransposeMatrixd(const GLdouble *m);                                                  \

    void loadTransposeMatrixf(const GLfloat *m);                                                   \

    void multTransposeMatrixd(const GLdouble *m);                                                  \

    void multTransposeMatrixf(const GLfloat *m);                                                   \

    void multiTexCoord1d(GLenum target, GLdouble s);                                               \

    void multiTexCoord1dv(GLenum target, const GLdouble *v);                                       \

    void multiTexCoord1f(GLenum target, GLfloat s);                                                \

    void multiTexCoord1fv(GLenum target, const GLfloat *v);                                        \

    void multiTexCoord1i(GLenum target, GLint s);                                                  \

    void multiTexCoord1iv(GLenum target, const GLint *v);                                          \

    void multiTexCoord1s(GLenum target, GLshort s);                                                \

    void multiTexCoord1sv(GLenum target, const GLshort *v);                                        \

    void multiTexCoord2d(GLenum target, GLdouble s, GLdouble t);                                   \

    void multiTexCoord2dv(GLenum target, const GLdouble *v);                                       \

    void multiTexCoord2f(GLenum target, GLfloat s, GLfloat t);                                     \

    void multiTexCoord2fv(GLenum target, const GLfloat *v);                                        \

    void multiTexCoord2i(GLenum target, GLint s, GLint t);                                         \

    void multiTexCoord2iv(GLenum target, const GLint *v);                                          \

    void multiTexCoord2s(GLenum target, GLshort s, GLshort t);                                     \

    void multiTexCoord2sv(GLenum target, const GLshort *v);                                        \

    void multiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);                       \

    void multiTexCoord3dv(GLenum target, const GLdouble *v);                                       \

    void multiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);                          \

    void multiTexCoord3fv(GLenum target, const GLfloat *v);                                        \

    void multiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);                                \

    void multiTexCoord3iv(GLenum target, const GLint *v);                                          \

    void multiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);                          \

    void multiTexCoord3sv(GLenum target, const GLshort *v);                                        \

    void multiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);           \

    void multiTexCoord4dv(GLenum target, const GLdouble *v);                                       \

    void multiTexCoord4fv(GLenum target, const GLfloat *v);                                        \

    void multiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);                       \

    void multiTexCoord4iv(GLenum target, const GLint *v);                                          \

    void multiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);               \

    void multiTexCoord4sv(GLenum target, const GLshort *v);                                        \

    void fogCoordPointer(GLenum type, GLsizei stride, const void *pointer);                        \

    void fogCoordd(GLdouble coord);                                                                \

    void fogCoorddv(const GLdouble *coord);                                                        \

    void fogCoordf(GLfloat coord);                                                                 \

    void fogCoordfv(const GLfloat *coord);                                                         \

    void pointParameteri(GLenum pname, GLint param);                                               \

    void pointParameteriv(GLenum pname, const GLint *params);                                      \

    void secondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);                                  \

    void secondaryColor3bv(const GLbyte *v);                                                       \

    void secondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);                            \

    void secondaryColor3dv(const GLdouble *v);                                                     \

    void secondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);                               \

    void secondaryColor3fv(const GLfloat *v);                                                      \

    void secondaryColor3i(GLint red, GLint green, GLint blue);                                     \

    void secondaryColor3iv(const GLint *v);                                                        \

    void secondaryColor3s(GLshort red, GLshort green, GLshort blue);                               \

    void secondaryColor3sv(const GLshort *v);                                                      \

    void secondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);                              \

    void secondaryColor3ubv(const GLubyte *v);                                                     \

    void secondaryColor3ui(GLuint red, GLuint green, GLuint blue);                                 \

    void secondaryColor3uiv(const GLuint *v);                                                      \

    void secondaryColor3us(GLushort red, GLushort green, GLushort blue);                           \

    void secondaryColor3usv(const GLushort *v);                                                    \

    void secondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);      \

    void windowPos2d(GLdouble x, GLdouble y);                                                      \

    void windowPos2dv(const GLdouble *v);                                                          \

    void windowPos2f(GLfloat x, GLfloat y);                                                        \

    void windowPos2fv(const GLfloat *v);                                                           \

    void windowPos2i(GLint x, GLint y);                                                            \

    void windowPos2iv(const GLint *v);                                                             \

    void windowPos2s(GLshort x, GLshort y);                                                        \

    void windowPos2sv(const GLshort *v);                                                           \

    void windowPos3d(GLdouble x, GLdouble y, GLdouble z);                                          \

    void windowPos3dv(const GLdouble *v);                                                          \

    void windowPos3f(GLfloat x, GLfloat y, GLfloat z);                                             \

    void windowPos3fv(const GLfloat *v);                                                           \

    void windowPos3i(GLint x, GLint y, GLint z);                                                   \

    void windowPos3iv(const GLint *v);                                                             \

    void windowPos3s(GLshort x, GLshort y, GLshort z);                                             \

    void windowPos3sv(const GLshort *v);                                                           \

    void getBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data);

#endif  // ANGLE_CONTEXT_API_1_AUTOGEN_H_

Source code

Revision control

Copy as Markdown

Other Tools