~mmach/netext73/webkit2gtk

« back to all changes in this revision

Viewing changes to Source/ThirdParty/ANGLE/src/libANGLE/Context_gl_1_0_autogen.h

  • Committer: mmach
  • Date: 2023-06-16 17:21:37 UTC
  • Revision ID: netbit73@gmail.com-20230616172137-2rqx6yr96ga9g3kp
1

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
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);                                                                 \
 
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_