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_0_autogen.h: Creates a macro for interfaces in Context.
9 
10 #ifndef ANGLE_CONTEXT_GL_1_0_AUTOGEN_H_
11 #define ANGLE_CONTEXT_GL_1_0_AUTOGEN_H_
12 
13 #define ANGLE_GL_1_0_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 
253 #endif  // ANGLE_CONTEXT_API_1_0_AUTOGEN_H_
254