1 /**************************************************************************
2
3 Copyright 2002 VMware, Inc.
4 Copyright 2011 Dave Airlie (ARB_vertex_type_2_10_10_10_rev support)
5 All Rights Reserved.
6
7 Permission is hereby granted, free of charge, to any person obtaining a
8 copy of this software and associated documentation files (the "Software"),
9 to deal in the Software without restriction, including without limitation
10 on the rights to use, copy, modify, merge, publish, distribute, sub
11 license, and/or sell copies of the Software, and to permit persons to whom
12 the Software is furnished to do so, subject to the following conditions:
13
14 The above copyright notice and this permission notice (including the next
15 paragraph) shall be included in all copies or substantial portions of the
16 Software.
17
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
22 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24 USE OR OTHER DEALINGS IN THE SOFTWARE.
25
26 **************************************************************************/
27
28 #include "util/format_r11g11b10f.h"
29 #include "main/varray.h"
30 #include "vbo_util.h"
31 #include "util/half_float.h"
32
33 #ifdef SUPPRESS_STATIC
34 #define static
35 #endif
36
37 /* ATTR */
38 #define ATTRI( A, N, V0, V1, V2, V3 ) \
39 ATTR_UNION(A, N, GL_INT, uint32_t, INT_AS_UINT(V0), INT_AS_UINT(V1), \
40 INT_AS_UINT(V2), INT_AS_UINT(V3))
41 #define ATTRUI( A, N, V0, V1, V2, V3 ) \
42 ATTR_UNION(A, N, GL_UNSIGNED_INT, uint32_t, (uint32_t)(V0), (uint32_t)(V1), \
43 (uint32_t)(V2), (uint32_t)(V3))
44 #define ATTRF( A, N, V0, V1, V2, V3 ) \
45 ATTR_UNION(A, N, GL_FLOAT, uint32_t, FLOAT_AS_UINT(V0), FLOAT_AS_UINT(V1),\
46 FLOAT_AS_UINT(V2), FLOAT_AS_UINT(V3))
47 #define ATTRD( A, N, V0, V1, V2, V3 ) \
48 ATTR_UNION(A, N, GL_DOUBLE, uint64_t, DOUBLE_AS_UINT64(V0), \
49 DOUBLE_AS_UINT64(V1), DOUBLE_AS_UINT64(V2), DOUBLE_AS_UINT64(V3))
50 #define ATTRUI64( A, N, V0, V1, V2, V3 ) \
51 ATTR_UNION(A, N, GL_UNSIGNED_INT64_ARB, uint64_t, V0, V1, V2, V3)
52
53
54 /* float */
55 #define ATTR1FV( A, V ) ATTRF( A, 1, (V)[0], 0, 0, 1 )
56 #define ATTR2FV( A, V ) ATTRF( A, 2, (V)[0], (V)[1], 0, 1 )
57 #define ATTR3FV( A, V ) ATTRF( A, 3, (V)[0], (V)[1], (V)[2], 1 )
58 #define ATTR4FV( A, V ) ATTRF( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
59
60 #define ATTR1F( A, X ) ATTRF( A, 1, X, 0, 0, 1 )
61 #define ATTR2F( A, X, Y ) ATTRF( A, 2, X, Y, 0, 1 )
62 #define ATTR3F( A, X, Y, Z ) ATTRF( A, 3, X, Y, Z, 1 )
63 #define ATTR4F( A, X, Y, Z, W ) ATTRF( A, 4, X, Y, Z, W )
64
65
66 /* half */
67 #define ATTR1HV( A, V ) ATTRF( A, 1, _mesa_half_to_float((uint16_t)(V)[0]), \
68 0, 0, 1 )
69 #define ATTR2HV( A, V ) ATTRF( A, 2, _mesa_half_to_float((uint16_t)(V)[0]), \
70 _mesa_half_to_float((uint16_t)(V)[1]), 0, 1 )
71 #define ATTR3HV( A, V ) ATTRF( A, 3, _mesa_half_to_float((uint16_t)(V)[0]), \
72 _mesa_half_to_float((uint16_t)(V)[1]), \
73 _mesa_half_to_float((uint16_t)(V)[2]), 1 )
74 #define ATTR4HV( A, V ) ATTRF( A, 4, _mesa_half_to_float((uint16_t)(V)[0]), \
75 _mesa_half_to_float((uint16_t)(V)[1]), \
76 _mesa_half_to_float((uint16_t)(V)[2]), \
77 _mesa_half_to_float((uint16_t)(V)[3]) )
78
79 #define ATTR1H( A, X ) ATTRF( A, 1, _mesa_half_to_float(X), 0, 0, 1 )
80 #define ATTR2H( A, X, Y ) ATTRF( A, 2, _mesa_half_to_float(X), \
81 _mesa_half_to_float(Y), 0, 1 )
82 #define ATTR3H( A, X, Y, Z ) ATTRF( A, 3, _mesa_half_to_float(X), \
83 _mesa_half_to_float(Y), \
84 _mesa_half_to_float(Z), 1 )
85 #define ATTR4H( A, X, Y, Z, W ) ATTRF( A, 4, _mesa_half_to_float(X), \
86 _mesa_half_to_float(Y), \
87 _mesa_half_to_float(Z), \
88 _mesa_half_to_float(W) )
89
90
91 /* int */
92 #define ATTR2IV( A, V ) ATTRI( A, 2, (V)[0], (V)[1], 0, 1 )
93 #define ATTR3IV( A, V ) ATTRI( A, 3, (V)[0], (V)[1], (V)[2], 1 )
94 #define ATTR4IV( A, V ) ATTRI( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
95
96 #define ATTR1I( A, X ) ATTRI( A, 1, X, 0, 0, 1 )
97 #define ATTR2I( A, X, Y ) ATTRI( A, 2, X, Y, 0, 1 )
98 #define ATTR3I( A, X, Y, Z ) ATTRI( A, 3, X, Y, Z, 1 )
99 #define ATTR4I( A, X, Y, Z, W ) ATTRI( A, 4, X, Y, Z, W )
100
101
102 /* uint */
103 #define ATTR2UIV( A, V ) ATTRUI( A, 2, (V)[0], (V)[1], 0, 1 )
104 #define ATTR3UIV( A, V ) ATTRUI( A, 3, (V)[0], (V)[1], (V)[2], 1 )
105 #define ATTR4UIV( A, V ) ATTRUI( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
106
107 #define ATTR1UI( A, X ) ATTRUI( A, 1, X, 0, 0, 1 )
108 #define ATTR2UI( A, X, Y ) ATTRUI( A, 2, X, Y, 0, 1 )
109 #define ATTR3UI( A, X, Y, Z ) ATTRUI( A, 3, X, Y, Z, 1 )
110 #define ATTR4UI( A, X, Y, Z, W ) ATTRUI( A, 4, X, Y, Z, W )
111
112 #define MAT_ATTR( A, N, V ) ATTRF( A, N, (V)[0], (V)[1], (V)[2], (V)[3] )
113
114 #define ATTRUI10_1( A, UI ) ATTRF( A, 1, (UI) & 0x3ff, 0, 0, 1 )
115 #define ATTRUI10_2( A, UI ) ATTRF( A, 2, (UI) & 0x3ff, ((UI) >> 10) & 0x3ff, 0, 1 )
116 #define ATTRUI10_3( A, UI ) ATTRF( A, 3, (UI) & 0x3ff, ((UI) >> 10) & 0x3ff, ((UI) >> 20) & 0x3ff, 1 )
117 #define ATTRUI10_4( A, UI ) ATTRF( A, 4, (UI) & 0x3ff, ((UI) >> 10) & 0x3ff, ((UI) >> 20) & 0x3ff, ((UI) >> 30) & 0x3 )
118
119 #define ATTRUI10N_1( A, UI ) ATTRF( A, 1, conv_ui10_to_norm_float((UI) & 0x3ff), 0, 0, 1 )
120 #define ATTRUI10N_2( A, UI ) ATTRF( A, 2, \
121 conv_ui10_to_norm_float((UI) & 0x3ff), \
122 conv_ui10_to_norm_float(((UI) >> 10) & 0x3ff), 0, 1 )
123 #define ATTRUI10N_3( A, UI ) ATTRF( A, 3, \
124 conv_ui10_to_norm_float((UI) & 0x3ff), \
125 conv_ui10_to_norm_float(((UI) >> 10) & 0x3ff), \
126 conv_ui10_to_norm_float(((UI) >> 20) & 0x3ff), 1 )
127 #define ATTRUI10N_4( A, UI ) ATTRF( A, 4, \
128 conv_ui10_to_norm_float((UI) & 0x3ff), \
129 conv_ui10_to_norm_float(((UI) >> 10) & 0x3ff), \
130 conv_ui10_to_norm_float(((UI) >> 20) & 0x3ff), \
131 conv_ui2_to_norm_float(((UI) >> 30) & 0x3) )
132
133 #define ATTRI10_1( A, I10 ) ATTRF( A, 1, conv_i10_to_i((I10) & 0x3ff), 0, 0, 1 )
134 #define ATTRI10_2( A, I10 ) ATTRF( A, 2, \
135 conv_i10_to_i((I10) & 0x3ff), \
136 conv_i10_to_i(((I10) >> 10) & 0x3ff), 0, 1 )
137 #define ATTRI10_3( A, I10 ) ATTRF( A, 3, \
138 conv_i10_to_i((I10) & 0x3ff), \
139 conv_i10_to_i(((I10) >> 10) & 0x3ff), \
140 conv_i10_to_i(((I10) >> 20) & 0x3ff), 1 )
141 #define ATTRI10_4( A, I10 ) ATTRF( A, 4, \
142 conv_i10_to_i((I10) & 0x3ff), \
143 conv_i10_to_i(((I10) >> 10) & 0x3ff), \
144 conv_i10_to_i(((I10) >> 20) & 0x3ff), \
145 conv_i2_to_i(((I10) >> 30) & 0x3))
146
147
148 #define ATTRI10N_1(ctx, A, I10) ATTRF(A, 1, conv_i10_to_norm_float(ctx, (I10) & 0x3ff), 0, 0, 1 )
149 #define ATTRI10N_2(ctx, A, I10) ATTRF(A, 2, \
150 conv_i10_to_norm_float(ctx, (I10) & 0x3ff), \
151 conv_i10_to_norm_float(ctx, ((I10) >> 10) & 0x3ff), 0, 1 )
152 #define ATTRI10N_3(ctx, A, I10) ATTRF(A, 3, \
153 conv_i10_to_norm_float(ctx, (I10) & 0x3ff), \
154 conv_i10_to_norm_float(ctx, ((I10) >> 10) & 0x3ff), \
155 conv_i10_to_norm_float(ctx, ((I10) >> 20) & 0x3ff), 1 )
156 #define ATTRI10N_4(ctx, A, I10) ATTRF(A, 4, \
157 conv_i10_to_norm_float(ctx, (I10) & 0x3ff), \
158 conv_i10_to_norm_float(ctx, ((I10) >> 10) & 0x3ff), \
159 conv_i10_to_norm_float(ctx, ((I10) >> 20) & 0x3ff), \
160 conv_i2_to_norm_float(ctx, ((I10) >> 30) & 0x3))
161
162 #define ATTR_UI(ctx, val, type, normalized, attr, arg) do { \
163 if ((type) == GL_UNSIGNED_INT_2_10_10_10_REV) { \
164 if (normalized) { \
165 ATTRUI10N_##val((attr), (arg)); \
166 } else { \
167 ATTRUI10_##val((attr), (arg)); \
168 } \
169 } else if ((type) == GL_INT_2_10_10_10_REV) { \
170 if (normalized) { \
171 ATTRI10N_##val(ctx, (attr), (arg)); \
172 } else { \
173 ATTRI10_##val((attr), (arg)); \
174 } \
175 } else if ((type) == GL_UNSIGNED_INT_10F_11F_11F_REV) { \
176 float res[4]; \
177 res[3] = 1; \
178 r11g11b10f_to_float3((arg), res); \
179 ATTR##val##FV((attr), res); \
180 } else \
181 ERROR(GL_INVALID_VALUE); \
182 } while(0)
183
184 #define ATTR_UI_INDEX(ctx, val, type, normalized, index, arg) do { \
185 if ((index) == 0 && _mesa_attr_zero_aliases_vertex(ctx)) { \
186 ATTR_UI(ctx, val, (type), normalized, 0, (arg)); \
187 } else if ((index) < MAX_VERTEX_GENERIC_ATTRIBS) { \
188 ATTR_UI(ctx, val, (type), normalized, VBO_ATTRIB_GENERIC0 + (index), (arg)); \
189 } else \
190 ERROR(GL_INVALID_VALUE); \
191 } while(0)
192
193
194 /* Doubles */
195 #define ATTR1DV( A, V ) ATTRD( A, 1, (V)[0], 0, 0, 1 )
196 #define ATTR2DV( A, V ) ATTRD( A, 2, (V)[0], (V)[1], 0, 1 )
197 #define ATTR3DV( A, V ) ATTRD( A, 3, (V)[0], (V)[1], (V)[2], 1 )
198 #define ATTR4DV( A, V ) ATTRD( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
199
200 #define ATTR1D( A, X ) ATTRD( A, 1, X, 0, 0, 1 )
201 #define ATTR2D( A, X, Y ) ATTRD( A, 2, X, Y, 0, 1 )
202 #define ATTR3D( A, X, Y, Z ) ATTRD( A, 3, X, Y, Z, 1 )
203 #define ATTR4D( A, X, Y, Z, W ) ATTRD( A, 4, X, Y, Z, W )
204
205 #define ATTR1UIV64( A, V ) ATTRUI64( A, 1, (V)[0], 0, 0, 0 )
206 #define ATTR1UI64( A, X ) ATTRUI64( A, 1, X, 0, 0, 0 )
207
208
209 static void GLAPIENTRY
TAG(Vertex2f)210 TAG(Vertex2f)(GLfloat x, GLfloat y)
211 {
212 GET_CURRENT_CONTEXT(ctx);
213 ATTR2F(VBO_ATTRIB_POS, x, y);
214 }
215
216 static void GLAPIENTRY
TAG(Vertex2fv)217 TAG(Vertex2fv)(const GLfloat * v)
218 {
219 GET_CURRENT_CONTEXT(ctx);
220 ATTR2FV(VBO_ATTRIB_POS, v);
221 }
222
223 static void GLAPIENTRY
TAG(Vertex3f)224 TAG(Vertex3f)(GLfloat x, GLfloat y, GLfloat z)
225 {
226 GET_CURRENT_CONTEXT(ctx);
227 ATTR3F(VBO_ATTRIB_POS, x, y, z);
228 }
229
230 static void GLAPIENTRY
TAG(Vertex3fv)231 TAG(Vertex3fv)(const GLfloat * v)
232 {
233 GET_CURRENT_CONTEXT(ctx);
234 ATTR3FV(VBO_ATTRIB_POS, v);
235 }
236
237 static void GLAPIENTRY
TAG(Vertex4f)238 TAG(Vertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
239 {
240 GET_CURRENT_CONTEXT(ctx);
241 ATTR4F(VBO_ATTRIB_POS, x, y, z, w);
242 }
243
244 static void GLAPIENTRY
TAG(Vertex4fv)245 TAG(Vertex4fv)(const GLfloat * v)
246 {
247 GET_CURRENT_CONTEXT(ctx);
248 ATTR4FV(VBO_ATTRIB_POS, v);
249 }
250
251 static void GLAPIENTRY
TAG(VertexAttrib1fARB)252 TAG(VertexAttrib1fARB)(GLuint index, GLfloat x)
253 {
254 GET_CURRENT_CONTEXT(ctx);
255 if (is_vertex_position(ctx, index))
256 ATTR1F(0, x);
257 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
258 ATTR1F(VBO_ATTRIB_GENERIC0 + index, x);
259 else
260 ERROR(GL_INVALID_VALUE);
261 }
262
263 static void GLAPIENTRY
TAG(VertexAttrib1fvARB)264 TAG(VertexAttrib1fvARB)(GLuint index, const GLfloat * v)
265 {
266 GET_CURRENT_CONTEXT(ctx);
267 if (is_vertex_position(ctx, index))
268 ATTR1FV(0, v);
269 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
270 ATTR1FV(VBO_ATTRIB_GENERIC0 + index, v);
271 else
272 ERROR(GL_INVALID_VALUE);
273 }
274
275 static void GLAPIENTRY
TAG(VertexAttrib2fARB)276 TAG(VertexAttrib2fARB)(GLuint index, GLfloat x, GLfloat y)
277 {
278 GET_CURRENT_CONTEXT(ctx);
279 if (is_vertex_position(ctx, index))
280 ATTR2F(0, x, y);
281 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
282 ATTR2F(VBO_ATTRIB_GENERIC0 + index, x, y);
283 else
284 ERROR(GL_INVALID_VALUE);
285 }
286
287 static void GLAPIENTRY
TAG(VertexAttrib2fvARB)288 TAG(VertexAttrib2fvARB)(GLuint index, const GLfloat * v)
289 {
290 GET_CURRENT_CONTEXT(ctx);
291 if (is_vertex_position(ctx, index))
292 ATTR2FV(0, v);
293 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
294 ATTR2FV(VBO_ATTRIB_GENERIC0 + index, v);
295 else
296 ERROR(GL_INVALID_VALUE);
297 }
298
299 static void GLAPIENTRY
TAG(VertexAttrib3fARB)300 TAG(VertexAttrib3fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z)
301 {
302 GET_CURRENT_CONTEXT(ctx);
303 if (is_vertex_position(ctx, index))
304 ATTR3F(0, x, y, z);
305 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
306 ATTR3F(VBO_ATTRIB_GENERIC0 + index, x, y, z);
307 else
308 ERROR(GL_INVALID_VALUE);
309 }
310
311 static void GLAPIENTRY
TAG(VertexAttrib3fvARB)312 TAG(VertexAttrib3fvARB)(GLuint index, const GLfloat * v)
313 {
314 GET_CURRENT_CONTEXT(ctx);
315 if (is_vertex_position(ctx, index))
316 ATTR3FV(0, v);
317 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
318 ATTR3FV(VBO_ATTRIB_GENERIC0 + index, v);
319 else
320 ERROR(GL_INVALID_VALUE);
321 }
322
323 static void GLAPIENTRY
TAG(VertexAttrib4fARB)324 TAG(VertexAttrib4fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
325 {
326 GET_CURRENT_CONTEXT(ctx);
327 if (is_vertex_position(ctx, index))
328 ATTR4F(0, x, y, z, w);
329 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
330 ATTR4F(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
331 else
332 ERROR(GL_INVALID_VALUE);
333 }
334
335 static void GLAPIENTRY
TAG(VertexAttrib4fvARB)336 TAG(VertexAttrib4fvARB)(GLuint index, const GLfloat * v)
337 {
338 GET_CURRENT_CONTEXT(ctx);
339 if (is_vertex_position(ctx, index))
340 ATTR4FV(0, v);
341 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
342 ATTR4FV(VBO_ATTRIB_GENERIC0 + index, v);
343 else
344 ERROR(GL_INVALID_VALUE);
345 }
346
347
348
349 /* Integer-valued generic attributes.
350 * XXX: the integers just get converted to floats at this time
351 */
352 static void GLAPIENTRY
TAG(VertexAttribI1iEXT)353 TAG(VertexAttribI1iEXT)(GLuint index, GLint x)
354 {
355 GET_CURRENT_CONTEXT(ctx);
356 if (is_vertex_position(ctx, index))
357 ATTR1I(0, x);
358 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
359 ATTR1I(VBO_ATTRIB_GENERIC0 + index, x);
360 else
361 ERROR(GL_INVALID_VALUE);
362 }
363
364 static void GLAPIENTRY
TAG(VertexAttribI2iEXT)365 TAG(VertexAttribI2iEXT)(GLuint index, GLint x, GLint y)
366 {
367 GET_CURRENT_CONTEXT(ctx);
368 if (is_vertex_position(ctx, index))
369 ATTR2I(0, x, y);
370 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
371 ATTR2I(VBO_ATTRIB_GENERIC0 + index, x, y);
372 else
373 ERROR(GL_INVALID_VALUE);
374 }
375
376 static void GLAPIENTRY
TAG(VertexAttribI3iEXT)377 TAG(VertexAttribI3iEXT)(GLuint index, GLint x, GLint y, GLint z)
378 {
379 GET_CURRENT_CONTEXT(ctx);
380 if (is_vertex_position(ctx, index))
381 ATTR3I(0, x, y, z);
382 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
383 ATTR3I(VBO_ATTRIB_GENERIC0 + index, x, y, z);
384 else
385 ERROR(GL_INVALID_VALUE);
386 }
387
388 static void GLAPIENTRY
TAG(VertexAttribI4iEXT)389 TAG(VertexAttribI4iEXT)(GLuint index, GLint x, GLint y, GLint z, GLint w)
390 {
391 GET_CURRENT_CONTEXT(ctx);
392 if (is_vertex_position(ctx, index))
393 ATTR4I(0, x, y, z, w);
394 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
395 ATTR4I(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
396 else
397 ERROR(GL_INVALID_VALUE);
398 }
399
400 static void GLAPIENTRY
TAG(VertexAttribI2ivEXT)401 TAG(VertexAttribI2ivEXT)(GLuint index, const GLint *v)
402 {
403 GET_CURRENT_CONTEXT(ctx);
404 if (is_vertex_position(ctx, index))
405 ATTR2IV(0, v);
406 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
407 ATTR2IV(VBO_ATTRIB_GENERIC0 + index, v);
408 else
409 ERROR(GL_INVALID_VALUE);
410 }
411
412 static void GLAPIENTRY
TAG(VertexAttribI3ivEXT)413 TAG(VertexAttribI3ivEXT)(GLuint index, const GLint *v)
414 {
415 GET_CURRENT_CONTEXT(ctx);
416 if (is_vertex_position(ctx, index))
417 ATTR3IV(0, v);
418 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
419 ATTR3IV(VBO_ATTRIB_GENERIC0 + index, v);
420 else
421 ERROR(GL_INVALID_VALUE);
422 }
423
424 static void GLAPIENTRY
TAG(VertexAttribI4ivEXT)425 TAG(VertexAttribI4ivEXT)(GLuint index, const GLint *v)
426 {
427 GET_CURRENT_CONTEXT(ctx);
428 if (is_vertex_position(ctx, index))
429 ATTR4IV(0, v);
430 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
431 ATTR4IV(VBO_ATTRIB_GENERIC0 + index, v);
432 else
433 ERROR(GL_INVALID_VALUE);
434 }
435
436
437
438 /* Unsigned integer-valued generic attributes.
439 * XXX: the integers just get converted to floats at this time
440 */
441 static void GLAPIENTRY
TAG(VertexAttribI1uiEXT)442 TAG(VertexAttribI1uiEXT)(GLuint index, GLuint x)
443 {
444 GET_CURRENT_CONTEXT(ctx);
445 if (is_vertex_position(ctx, index))
446 ATTR1UI(0, x);
447 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
448 ATTR1UI(VBO_ATTRIB_GENERIC0 + index, x);
449 else
450 ERROR(GL_INVALID_VALUE);
451 }
452
453 static void GLAPIENTRY
TAG(VertexAttribI2uiEXT)454 TAG(VertexAttribI2uiEXT)(GLuint index, GLuint x, GLuint y)
455 {
456 GET_CURRENT_CONTEXT(ctx);
457 if (is_vertex_position(ctx, index))
458 ATTR2UI(0, x, y);
459 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
460 ATTR2UI(VBO_ATTRIB_GENERIC0 + index, x, y);
461 else
462 ERROR(GL_INVALID_VALUE);
463 }
464
465 static void GLAPIENTRY
TAG(VertexAttribI3uiEXT)466 TAG(VertexAttribI3uiEXT)(GLuint index, GLuint x, GLuint y, GLuint z)
467 {
468 GET_CURRENT_CONTEXT(ctx);
469 if (is_vertex_position(ctx, index))
470 ATTR3UI(0, x, y, z);
471 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
472 ATTR3UI(VBO_ATTRIB_GENERIC0 + index, x, y, z);
473 else
474 ERROR(GL_INVALID_VALUE);
475 }
476
477 static void GLAPIENTRY
TAG(VertexAttribI4uiEXT)478 TAG(VertexAttribI4uiEXT)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
479 {
480 GET_CURRENT_CONTEXT(ctx);
481 if (is_vertex_position(ctx, index))
482 ATTR4UI(0, x, y, z, w);
483 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
484 ATTR4UI(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
485 else
486 ERROR(GL_INVALID_VALUE);
487 }
488
489 static void GLAPIENTRY
TAG(VertexAttribI2uivEXT)490 TAG(VertexAttribI2uivEXT)(GLuint index, const GLuint *v)
491 {
492 GET_CURRENT_CONTEXT(ctx);
493 if (is_vertex_position(ctx, index))
494 ATTR2UIV(0, v);
495 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
496 ATTR2UIV(VBO_ATTRIB_GENERIC0 + index, v);
497 else
498 ERROR(GL_INVALID_VALUE);
499 }
500
501 static void GLAPIENTRY
TAG(VertexAttribI3uivEXT)502 TAG(VertexAttribI3uivEXT)(GLuint index, const GLuint *v)
503 {
504 GET_CURRENT_CONTEXT(ctx);
505 if (is_vertex_position(ctx, index))
506 ATTR3UIV(0, v);
507 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
508 ATTR3UIV(VBO_ATTRIB_GENERIC0 + index, v);
509 else
510 ERROR(GL_INVALID_VALUE);
511 }
512
513 static void GLAPIENTRY
TAG(VertexAttribI4uivEXT)514 TAG(VertexAttribI4uivEXT)(GLuint index, const GLuint *v)
515 {
516 GET_CURRENT_CONTEXT(ctx);
517 if (is_vertex_position(ctx, index))
518 ATTR4UIV(0, v);
519 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
520 ATTR4UIV(VBO_ATTRIB_GENERIC0 + index, v);
521 else
522 ERROR(GL_INVALID_VALUE);
523 }
524
525
526
527 /* These entrypoints are no longer used for NV_vertex_program but they are
528 * used by the display list and other code specifically because of their
529 * property of aliasing with the legacy Vertex, TexCoord, Normal, etc
530 * attributes. (See vbo_save_loopback.c)
531 */
532 static void GLAPIENTRY
TAG(VertexAttrib1fNV)533 TAG(VertexAttrib1fNV)(GLuint index, GLfloat x)
534 {
535 GET_CURRENT_CONTEXT(ctx);
536 if (index < VBO_ATTRIB_MAX)
537 ATTR1F(index, x);
538 }
539
540 static void GLAPIENTRY
TAG(VertexAttrib1fvNV)541 TAG(VertexAttrib1fvNV)(GLuint index, const GLfloat * v)
542 {
543 GET_CURRENT_CONTEXT(ctx);
544 if (index < VBO_ATTRIB_MAX)
545 ATTR1FV(index, v);
546 }
547
548 static void GLAPIENTRY
TAG(VertexAttrib2fNV)549 TAG(VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y)
550 {
551 GET_CURRENT_CONTEXT(ctx);
552 if (index < VBO_ATTRIB_MAX)
553 ATTR2F(index, x, y);
554 }
555
556 static void GLAPIENTRY
TAG(VertexAttrib2fvNV)557 TAG(VertexAttrib2fvNV)(GLuint index, const GLfloat * v)
558 {
559 GET_CURRENT_CONTEXT(ctx);
560 if (index < VBO_ATTRIB_MAX)
561 ATTR2FV(index, v);
562 }
563
564 static void GLAPIENTRY
TAG(VertexAttrib3fNV)565 TAG(VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z)
566 {
567 GET_CURRENT_CONTEXT(ctx);
568 if (index < VBO_ATTRIB_MAX)
569 ATTR3F(index, x, y, z);
570 }
571
572 static void GLAPIENTRY
TAG(VertexAttrib3fvNV)573 TAG(VertexAttrib3fvNV)(GLuint index,
574 const GLfloat * v)
575 {
576 GET_CURRENT_CONTEXT(ctx);
577 if (index < VBO_ATTRIB_MAX)
578 ATTR3FV(index, v);
579 }
580
581 static void GLAPIENTRY
TAG(VertexAttrib4fNV)582 TAG(VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
583 {
584 GET_CURRENT_CONTEXT(ctx);
585 if (index < VBO_ATTRIB_MAX)
586 ATTR4F(index, x, y, z, w);
587 }
588
589 static void GLAPIENTRY
TAG(VertexAttrib4fvNV)590 TAG(VertexAttrib4fvNV)(GLuint index, const GLfloat * v)
591 {
592 GET_CURRENT_CONTEXT(ctx);
593 if (index < VBO_ATTRIB_MAX)
594 ATTR4FV(index, v);
595 }
596
597 static void GLAPIENTRY
TAG(VertexP2ui)598 TAG(VertexP2ui)(GLenum type, GLuint value)
599 {
600 GET_CURRENT_CONTEXT(ctx);
601 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexP2ui");
602 ATTR_UI(ctx, 2, type, 0, VBO_ATTRIB_POS, value);
603 }
604
605 static void GLAPIENTRY
TAG(VertexP2uiv)606 TAG(VertexP2uiv)(GLenum type, const GLuint *value)
607 {
608 GET_CURRENT_CONTEXT(ctx);
609 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexP2uiv");
610 ATTR_UI(ctx, 2, type, 0, VBO_ATTRIB_POS, value[0]);
611 }
612
613 static void GLAPIENTRY
TAG(VertexP3ui)614 TAG(VertexP3ui)(GLenum type, GLuint value)
615 {
616 GET_CURRENT_CONTEXT(ctx);
617 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexP3ui");
618 ATTR_UI(ctx, 3, type, 0, VBO_ATTRIB_POS, value);
619 }
620
621 static void GLAPIENTRY
TAG(VertexP3uiv)622 TAG(VertexP3uiv)(GLenum type, const GLuint *value)
623 {
624 GET_CURRENT_CONTEXT(ctx);
625 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexP3uiv");
626 ATTR_UI(ctx, 3, type, 0, VBO_ATTRIB_POS, value[0]);
627 }
628
629 static void GLAPIENTRY
TAG(VertexP4ui)630 TAG(VertexP4ui)(GLenum type, GLuint value)
631 {
632 GET_CURRENT_CONTEXT(ctx);
633 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexP4ui");
634 ATTR_UI(ctx, 4, type, 0, VBO_ATTRIB_POS, value);
635 }
636
637 static void GLAPIENTRY
TAG(VertexP4uiv)638 TAG(VertexP4uiv)(GLenum type, const GLuint *value)
639 {
640 GET_CURRENT_CONTEXT(ctx);
641 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexP4uiv");
642 ATTR_UI(ctx, 4, type, 0, VBO_ATTRIB_POS, value[0]);
643 }
644
645 static void GLAPIENTRY
TAG(VertexAttribP1ui)646 TAG(VertexAttribP1ui)(GLuint index, GLenum type, GLboolean normalized,
647 GLuint value)
648 {
649 GET_CURRENT_CONTEXT(ctx);
650 ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP1ui");
651 ATTR_UI_INDEX(ctx, 1, type, normalized, index, value);
652 }
653
654 static void GLAPIENTRY
TAG(VertexAttribP2ui)655 TAG(VertexAttribP2ui)(GLuint index, GLenum type, GLboolean normalized,
656 GLuint value)
657 {
658 GET_CURRENT_CONTEXT(ctx);
659 ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP2ui");
660 ATTR_UI_INDEX(ctx, 2, type, normalized, index, value);
661 }
662
663 static void GLAPIENTRY
TAG(VertexAttribP3ui)664 TAG(VertexAttribP3ui)(GLuint index, GLenum type, GLboolean normalized,
665 GLuint value)
666 {
667 GET_CURRENT_CONTEXT(ctx);
668 ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP3ui");
669 ATTR_UI_INDEX(ctx, 3, type, normalized, index, value);
670 }
671
672 static void GLAPIENTRY
TAG(VertexAttribP4ui)673 TAG(VertexAttribP4ui)(GLuint index, GLenum type, GLboolean normalized,
674 GLuint value)
675 {
676 GET_CURRENT_CONTEXT(ctx);
677 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexAttribP4ui");
678 ATTR_UI_INDEX(ctx, 4, type, normalized, index, value);
679 }
680
681 static void GLAPIENTRY
TAG(VertexAttribP1uiv)682 TAG(VertexAttribP1uiv)(GLuint index, GLenum type, GLboolean normalized,
683 const GLuint *value)
684 {
685 GET_CURRENT_CONTEXT(ctx);
686 ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP1uiv");
687 ATTR_UI_INDEX(ctx, 1, type, normalized, index, *value);
688 }
689
690 static void GLAPIENTRY
TAG(VertexAttribP2uiv)691 TAG(VertexAttribP2uiv)(GLuint index, GLenum type, GLboolean normalized,
692 const GLuint *value)
693 {
694 GET_CURRENT_CONTEXT(ctx);
695 ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP2uiv");
696 ATTR_UI_INDEX(ctx, 2, type, normalized, index, *value);
697 }
698
699 static void GLAPIENTRY
TAG(VertexAttribP3uiv)700 TAG(VertexAttribP3uiv)(GLuint index, GLenum type, GLboolean normalized,
701 const GLuint *value)
702 {
703 GET_CURRENT_CONTEXT(ctx);
704 ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP3uiv");
705 ATTR_UI_INDEX(ctx, 3, type, normalized, index, *value);
706 }
707
708 static void GLAPIENTRY
TAG(VertexAttribP4uiv)709 TAG(VertexAttribP4uiv)(GLuint index, GLenum type, GLboolean normalized,
710 const GLuint *value)
711 {
712 GET_CURRENT_CONTEXT(ctx);
713 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexAttribP4uiv");
714 ATTR_UI_INDEX(ctx, 4, type, normalized, index, *value);
715 }
716
717
718
719 static void GLAPIENTRY
TAG(VertexAttribL1d)720 TAG(VertexAttribL1d)(GLuint index, GLdouble x)
721 {
722 GET_CURRENT_CONTEXT(ctx);
723 if (is_vertex_position(ctx, index))
724 ATTR1D(0, x);
725 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
726 ATTR1D(VBO_ATTRIB_GENERIC0 + index, x);
727 else
728 ERROR(GL_INVALID_VALUE);
729 }
730
731 static void GLAPIENTRY
TAG(VertexAttribL1dv)732 TAG(VertexAttribL1dv)(GLuint index, const GLdouble * v)
733 {
734 GET_CURRENT_CONTEXT(ctx);
735 if (is_vertex_position(ctx, index))
736 ATTR1DV(0, v);
737 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
738 ATTR1DV(VBO_ATTRIB_GENERIC0 + index, v);
739 else
740 ERROR(GL_INVALID_VALUE);
741 }
742
743 static void GLAPIENTRY
TAG(VertexAttribL2d)744 TAG(VertexAttribL2d)(GLuint index, GLdouble x, GLdouble y)
745 {
746 GET_CURRENT_CONTEXT(ctx);
747 if (is_vertex_position(ctx, index))
748 ATTR2D(0, x, y);
749 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
750 ATTR2D(VBO_ATTRIB_GENERIC0 + index, x, y);
751 else
752 ERROR(GL_INVALID_VALUE);
753 }
754
755 static void GLAPIENTRY
TAG(VertexAttribL2dv)756 TAG(VertexAttribL2dv)(GLuint index, const GLdouble * v)
757 {
758 GET_CURRENT_CONTEXT(ctx);
759 if (is_vertex_position(ctx, index))
760 ATTR2DV(0, v);
761 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
762 ATTR2DV(VBO_ATTRIB_GENERIC0 + index, v);
763 else
764 ERROR(GL_INVALID_VALUE);
765 }
766
767 static void GLAPIENTRY
TAG(VertexAttribL3d)768 TAG(VertexAttribL3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z)
769 {
770 GET_CURRENT_CONTEXT(ctx);
771 if (is_vertex_position(ctx, index))
772 ATTR3D(0, x, y, z);
773 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
774 ATTR3D(VBO_ATTRIB_GENERIC0 + index, x, y, z);
775 else
776 ERROR(GL_INVALID_VALUE);
777 }
778
779 static void GLAPIENTRY
TAG(VertexAttribL3dv)780 TAG(VertexAttribL3dv)(GLuint index, const GLdouble * v)
781 {
782 GET_CURRENT_CONTEXT(ctx);
783 if (is_vertex_position(ctx, index))
784 ATTR3DV(0, v);
785 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
786 ATTR3DV(VBO_ATTRIB_GENERIC0 + index, v);
787 else
788 ERROR(GL_INVALID_VALUE);
789 }
790
791 static void GLAPIENTRY
TAG(VertexAttribL4d)792 TAG(VertexAttribL4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
793 {
794 GET_CURRENT_CONTEXT(ctx);
795 if (is_vertex_position(ctx, index))
796 ATTR4D(0, x, y, z, w);
797 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
798 ATTR4D(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
799 else
800 ERROR(GL_INVALID_VALUE);
801 }
802
803 static void GLAPIENTRY
TAG(VertexAttribL4dv)804 TAG(VertexAttribL4dv)(GLuint index, const GLdouble * v)
805 {
806 GET_CURRENT_CONTEXT(ctx);
807 if (is_vertex_position(ctx, index))
808 ATTR4DV(0, v);
809 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
810 ATTR4DV(VBO_ATTRIB_GENERIC0 + index, v);
811 else
812 ERROR(GL_INVALID_VALUE);
813 }
814
815 static void GLAPIENTRY
TAG(VertexAttribL1ui64ARB)816 TAG(VertexAttribL1ui64ARB)(GLuint index, GLuint64EXT x)
817 {
818 GET_CURRENT_CONTEXT(ctx);
819 if (is_vertex_position(ctx, index))
820 ATTR1UI64(0, x);
821 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
822 ATTR1UI64(VBO_ATTRIB_GENERIC0 + index, x);
823 else
824 ERROR(GL_INVALID_VALUE);
825 }
826
827 static void GLAPIENTRY
TAG(VertexAttribL1ui64vARB)828 TAG(VertexAttribL1ui64vARB)(GLuint index, const GLuint64EXT *v)
829 {
830 GET_CURRENT_CONTEXT(ctx);
831 if (is_vertex_position(ctx, index))
832 ATTR1UIV64(0, v);
833 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
834 ATTR1UIV64(VBO_ATTRIB_GENERIC0 + index, v);
835 else
836 ERROR(GL_INVALID_VALUE);
837 }
838
839 /* GL_NV_half_float */
840 static void GLAPIENTRY
TAG(Vertex2hNV)841 TAG(Vertex2hNV)(GLhalfNV x, GLhalfNV y)
842 {
843 GET_CURRENT_CONTEXT(ctx);
844 ATTR2H(VBO_ATTRIB_POS, x, y);
845 }
846
847 static void GLAPIENTRY
TAG(Vertex2hvNV)848 TAG(Vertex2hvNV)(const GLhalfNV * v)
849 {
850 GET_CURRENT_CONTEXT(ctx);
851 ATTR2HV(VBO_ATTRIB_POS, v);
852 }
853
854 static void GLAPIENTRY
TAG(Vertex3hNV)855 TAG(Vertex3hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z)
856 {
857 GET_CURRENT_CONTEXT(ctx);
858 ATTR3H(VBO_ATTRIB_POS, x, y, z);
859 }
860
861 static void GLAPIENTRY
TAG(Vertex3hvNV)862 TAG(Vertex3hvNV)(const GLhalfNV * v)
863 {
864 GET_CURRENT_CONTEXT(ctx);
865 ATTR3HV(VBO_ATTRIB_POS, v);
866 }
867
868 static void GLAPIENTRY
TAG(Vertex4hNV)869 TAG(Vertex4hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
870 {
871 GET_CURRENT_CONTEXT(ctx);
872 ATTR4H(VBO_ATTRIB_POS, x, y, z, w);
873 }
874
875 static void GLAPIENTRY
TAG(Vertex4hvNV)876 TAG(Vertex4hvNV)(const GLhalfNV * v)
877 {
878 GET_CURRENT_CONTEXT(ctx);
879 ATTR4HV(VBO_ATTRIB_POS, v);
880 }
881
882 static void GLAPIENTRY
TAG(VertexAttrib1hNV)883 TAG(VertexAttrib1hNV)(GLuint index, GLhalfNV x)
884 {
885 GET_CURRENT_CONTEXT(ctx);
886 if (is_vertex_position(ctx, index))
887 ATTR1H(0, x);
888 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
889 ATTR1H(VBO_ATTRIB_GENERIC0 + index, x);
890 else
891 ERROR(GL_INVALID_VALUE);
892 }
893
894 static void GLAPIENTRY
TAG(VertexAttrib2hNV)895 TAG(VertexAttrib2hNV)(GLuint index, GLhalfNV x, GLhalfNV y)
896 {
897 GET_CURRENT_CONTEXT(ctx);
898 if (is_vertex_position(ctx, index))
899 ATTR2H(0, x, y);
900 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
901 ATTR2H(VBO_ATTRIB_GENERIC0 + index, x, y);
902 else
903 ERROR(GL_INVALID_VALUE);
904 }
905
906 static void GLAPIENTRY
TAG(VertexAttrib3hNV)907 TAG(VertexAttrib3hNV)(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z)
908 {
909 GET_CURRENT_CONTEXT(ctx);
910 if (is_vertex_position(ctx, index))
911 ATTR3H(0, x, y, z);
912 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
913 ATTR3H(VBO_ATTRIB_GENERIC0 + index, x, y, z);
914 else
915 ERROR(GL_INVALID_VALUE);
916 }
917
918 static void GLAPIENTRY
TAG(VertexAttrib4hNV)919 TAG(VertexAttrib4hNV)(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
920 {
921 GET_CURRENT_CONTEXT(ctx);
922 if (is_vertex_position(ctx, index))
923 ATTR4H(0, x, y, z, w);
924 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
925 ATTR4H(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
926 else
927 ERROR(GL_INVALID_VALUE);
928 }
929
930 static void GLAPIENTRY
TAG(VertexAttrib1hvNV)931 TAG(VertexAttrib1hvNV)(GLuint index, const GLhalfNV * v)
932 {
933 GET_CURRENT_CONTEXT(ctx);
934 if (is_vertex_position(ctx, index))
935 ATTR1HV(0, v);
936 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
937 ATTR1HV(VBO_ATTRIB_GENERIC0 + index, v);
938 else
939 ERROR(GL_INVALID_VALUE);
940 }
941
942 static void GLAPIENTRY
TAG(VertexAttrib2hvNV)943 TAG(VertexAttrib2hvNV)(GLuint index, const GLhalfNV * v)
944 {
945 GET_CURRENT_CONTEXT(ctx);
946 if (is_vertex_position(ctx, index))
947 ATTR2HV(0, v);
948 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
949 ATTR2HV(VBO_ATTRIB_GENERIC0 + index, v);
950 else
951 ERROR(GL_INVALID_VALUE);
952 }
953
954 static void GLAPIENTRY
TAG(VertexAttrib3hvNV)955 TAG(VertexAttrib3hvNV)(GLuint index, const GLhalfNV * v)
956 {
957 GET_CURRENT_CONTEXT(ctx);
958 if (is_vertex_position(ctx, index))
959 ATTR3HV(0, v);
960 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
961 ATTR3HV(VBO_ATTRIB_GENERIC0 + index, v);
962 else
963 ERROR(GL_INVALID_VALUE);
964 }
965
966 static void GLAPIENTRY
TAG(VertexAttrib4hvNV)967 TAG(VertexAttrib4hvNV)(GLuint index, const GLhalfNV * v)
968 {
969 GET_CURRENT_CONTEXT(ctx);
970 if (is_vertex_position(ctx, index))
971 ATTR4HV(0, v);
972 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
973 ATTR4HV(VBO_ATTRIB_GENERIC0 + index, v);
974 else
975 ERROR(GL_INVALID_VALUE);
976 }
977
978 static void GLAPIENTRY
TAG(VertexAttribs1hvNV)979 TAG(VertexAttribs1hvNV)(GLuint index, GLsizei n, const GLhalfNV *v)
980 {
981 GET_CURRENT_CONTEXT(ctx);
982 n = MIN2(n, VBO_ATTRIB_MAX - index);
983 for (GLint i = n - 1; i >= 0; i--)
984 ATTR1H(index + i, v[i]);
985 }
986
987 static void GLAPIENTRY
TAG(VertexAttribs2hvNV)988 TAG(VertexAttribs2hvNV)(GLuint index, GLsizei n, const GLhalfNV *v)
989 {
990 GET_CURRENT_CONTEXT(ctx);
991 n = MIN2(n, VBO_ATTRIB_MAX - index);
992 for (GLint i = n - 1; i >= 0; i--)
993 ATTR2H(index + i, v[2 * i], v[2 * i + 1]);
994 }
995
996 static void GLAPIENTRY
TAG(VertexAttribs3hvNV)997 TAG(VertexAttribs3hvNV)(GLuint index, GLsizei n, const GLhalfNV *v)
998 {
999 GET_CURRENT_CONTEXT(ctx);
1000 n = MIN2(n, VBO_ATTRIB_MAX - index);
1001 for (GLint i = n - 1; i >= 0; i--)
1002 ATTR3H(index + i, v[3 * i], v[3 * i + 1], v[3 * i + 2]);
1003 }
1004
1005
1006 static void GLAPIENTRY
TAG(VertexAttribs4hvNV)1007 TAG(VertexAttribs4hvNV)(GLuint index, GLsizei n, const GLhalfNV *v)
1008 {
1009 GET_CURRENT_CONTEXT(ctx);
1010 n = MIN2(n, VBO_ATTRIB_MAX - index);
1011 for (GLint i = n - 1; i >= 0; i--)
1012 ATTR4H(index + i, v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3]);
1013 }
1014
1015 static void GLAPIENTRY
TAG(Vertex2d)1016 TAG(Vertex2d)(GLdouble x, GLdouble y)
1017 {
1018 GET_CURRENT_CONTEXT(ctx);
1019 ATTR2F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y);
1020 }
1021
1022 static void GLAPIENTRY
TAG(Vertex2i)1023 TAG(Vertex2i)(GLint x, GLint y)
1024 {
1025 GET_CURRENT_CONTEXT(ctx);
1026 ATTR2F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y);
1027 }
1028
1029 static void GLAPIENTRY
TAG(Vertex2s)1030 TAG(Vertex2s)(GLshort x, GLshort y)
1031 {
1032 GET_CURRENT_CONTEXT(ctx);
1033 ATTR2F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y);
1034 }
1035
1036 static void GLAPIENTRY
TAG(Vertex3d)1037 TAG(Vertex3d)(GLdouble x, GLdouble y, GLdouble z)
1038 {
1039 GET_CURRENT_CONTEXT(ctx);
1040 ATTR3F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z);
1041 }
1042
1043 static void GLAPIENTRY
TAG(Vertex3i)1044 TAG(Vertex3i)(GLint x, GLint y, GLint z)
1045 {
1046 GET_CURRENT_CONTEXT(ctx);
1047 ATTR3F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z);
1048 }
1049
1050 static void GLAPIENTRY
TAG(Vertex3s)1051 TAG(Vertex3s)(GLshort x, GLshort y, GLshort z)
1052 {
1053 GET_CURRENT_CONTEXT(ctx);
1054 ATTR3F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z);
1055 }
1056
1057 static void GLAPIENTRY
TAG(Vertex4d)1058 TAG(Vertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1059 {
1060 GET_CURRENT_CONTEXT(ctx);
1061 ATTR4F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
1062 }
1063
1064 static void GLAPIENTRY
TAG(Vertex4i)1065 TAG(Vertex4i)(GLint x, GLint y, GLint z, GLint w)
1066 {
1067 GET_CURRENT_CONTEXT(ctx);
1068 ATTR4F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
1069 }
1070
1071 static void GLAPIENTRY
TAG(Vertex4s)1072 TAG(Vertex4s)(GLshort x, GLshort y, GLshort z, GLshort w)
1073 {
1074 GET_CURRENT_CONTEXT(ctx);
1075 ATTR4F(VBO_ATTRIB_POS, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
1076 }
1077
1078 static void GLAPIENTRY
TAG(Vertex2dv)1079 TAG(Vertex2dv)(const GLdouble *v)
1080 {
1081 GET_CURRENT_CONTEXT(ctx);
1082 ATTR2F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1]);
1083 }
1084
1085 static void GLAPIENTRY
TAG(Vertex2iv)1086 TAG(Vertex2iv)(const GLint *v)
1087 {
1088 GET_CURRENT_CONTEXT(ctx);
1089 ATTR2F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1]);
1090 }
1091
1092 static void GLAPIENTRY
TAG(Vertex2sv)1093 TAG(Vertex2sv)(const GLshort *v)
1094 {
1095 GET_CURRENT_CONTEXT(ctx);
1096 ATTR2F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1]);
1097 }
1098
1099 static void GLAPIENTRY
TAG(Vertex3dv)1100 TAG(Vertex3dv)(const GLdouble *v)
1101 {
1102 GET_CURRENT_CONTEXT(ctx);
1103 ATTR3F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
1104 }
1105
1106 static void GLAPIENTRY
TAG(Vertex3iv)1107 TAG(Vertex3iv)(const GLint *v)
1108 {
1109 GET_CURRENT_CONTEXT(ctx);
1110 ATTR3F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
1111 }
1112
1113 static void GLAPIENTRY
TAG(Vertex3sv)1114 TAG(Vertex3sv)(const GLshort *v)
1115 {
1116 GET_CURRENT_CONTEXT(ctx);
1117 ATTR3F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
1118 }
1119
1120 static void GLAPIENTRY
TAG(Vertex4dv)1121 TAG(Vertex4dv)(const GLdouble *v)
1122 {
1123 GET_CURRENT_CONTEXT(ctx);
1124 ATTR4F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1],
1125 (GLfloat) v[2], (GLfloat) v[3]);
1126 }
1127
1128 static void GLAPIENTRY
TAG(Vertex4iv)1129 TAG(Vertex4iv)(const GLint *v)
1130 {
1131 GET_CURRENT_CONTEXT(ctx);
1132 ATTR4F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1],
1133 (GLfloat) v[2], (GLfloat) v[3]);
1134 }
1135
1136 static void GLAPIENTRY
TAG(Vertex4sv)1137 TAG(Vertex4sv)(const GLshort *v)
1138 {
1139 GET_CURRENT_CONTEXT(ctx);
1140 ATTR4F(VBO_ATTRIB_POS, (GLfloat) v[0], (GLfloat) v[1],
1141 (GLfloat) v[2], (GLfloat) v[3]);
1142 }
1143
1144 /*
1145 * GL_NV_vertex_program:
1146 * Note that attribute indexes DO alias conventional vertex attributes.
1147 */
1148
1149 static void GLAPIENTRY
TAG(VertexAttrib1sNV)1150 TAG(VertexAttrib1sNV)(GLuint index, GLshort x)
1151 {
1152 GET_CURRENT_CONTEXT(ctx);
1153 if (index < VBO_ATTRIB_MAX) ATTR1F(index, (GLfloat) x);
1154 }
1155
1156 static void GLAPIENTRY
TAG(VertexAttrib1dNV)1157 TAG(VertexAttrib1dNV)(GLuint index, GLdouble x)
1158 {
1159 GET_CURRENT_CONTEXT(ctx);
1160 if (index < VBO_ATTRIB_MAX) ATTR1F(index, (GLfloat) x);
1161 }
1162
1163 static void GLAPIENTRY
TAG(VertexAttrib2sNV)1164 TAG(VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y)
1165 {
1166 GET_CURRENT_CONTEXT(ctx);
1167 if (index < VBO_ATTRIB_MAX) ATTR2F(index, (GLfloat) x, y);
1168 }
1169
1170 static void GLAPIENTRY
TAG(VertexAttrib2dNV)1171 TAG(VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y)
1172 {
1173 GET_CURRENT_CONTEXT(ctx);
1174 if (index < VBO_ATTRIB_MAX) ATTR2F(index, (GLfloat) x, (GLfloat) y);
1175 }
1176
1177 static void GLAPIENTRY
TAG(VertexAttrib3sNV)1178 TAG(VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z)
1179 {
1180 GET_CURRENT_CONTEXT(ctx);
1181 if (index < VBO_ATTRIB_MAX) ATTR3F(index, (GLfloat) x, (GLfloat) y, (GLfloat) z);
1182 }
1183
1184 static void GLAPIENTRY
TAG(VertexAttrib3dNV)1185 TAG(VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z)
1186 {
1187 GET_CURRENT_CONTEXT(ctx);
1188 if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
1189 }
1190
1191 static void GLAPIENTRY
TAG(VertexAttrib4sNV)1192 TAG(VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
1193 {
1194 GET_CURRENT_CONTEXT(ctx);
1195 if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
1196 }
1197
1198 static void GLAPIENTRY
TAG(VertexAttrib4dNV)1199 TAG(VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1200 {
1201 GET_CURRENT_CONTEXT(ctx);
1202 if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
1203 }
1204
1205 static void GLAPIENTRY
TAG(VertexAttrib4ubNV)1206 TAG(VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
1207 {
1208 GET_CURRENT_CONTEXT(ctx);
1209 if (index < VBO_ATTRIB_MAX) ATTR4F(index, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y),
1210 UBYTE_TO_FLOAT(z), UBYTE_TO_FLOAT(w));
1211 }
1212
1213 static void GLAPIENTRY
TAG(VertexAttrib1svNV)1214 TAG(VertexAttrib1svNV)(GLuint index, const GLshort *v)
1215 {
1216 GET_CURRENT_CONTEXT(ctx);
1217 if (index < VBO_ATTRIB_MAX) ATTR1F(index, (GLfloat) v[0]);
1218 }
1219
1220 static void GLAPIENTRY
TAG(VertexAttrib1dvNV)1221 TAG(VertexAttrib1dvNV)(GLuint index, const GLdouble *v)
1222 {
1223 GET_CURRENT_CONTEXT(ctx);
1224 if (index < VBO_ATTRIB_MAX) ATTR1F(index, (GLfloat) v[0]);
1225 }
1226
1227 static void GLAPIENTRY
TAG(VertexAttrib2svNV)1228 TAG(VertexAttrib2svNV)(GLuint index, const GLshort *v)
1229 {
1230 GET_CURRENT_CONTEXT(ctx);
1231 if (index < VBO_ATTRIB_MAX) ATTR2F(index, (GLfloat) v[0], (GLfloat) v[1]);
1232 }
1233
1234 static void GLAPIENTRY
TAG(VertexAttrib2dvNV)1235 TAG(VertexAttrib2dvNV)(GLuint index, const GLdouble *v)
1236 {
1237 GET_CURRENT_CONTEXT(ctx);
1238 if (index < VBO_ATTRIB_MAX) ATTR2F(index, (GLfloat) v[0], (GLfloat) v[1]);
1239 }
1240
1241 static void GLAPIENTRY
TAG(VertexAttrib3svNV)1242 TAG(VertexAttrib3svNV)(GLuint index, const GLshort *v)
1243 {
1244 GET_CURRENT_CONTEXT(ctx);
1245 if (index < VBO_ATTRIB_MAX) ATTR3F(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
1246 }
1247
1248 static void GLAPIENTRY
TAG(VertexAttrib3dvNV)1249 TAG(VertexAttrib3dvNV)(GLuint index, const GLdouble *v)
1250 {
1251 GET_CURRENT_CONTEXT(ctx);
1252 if (index < VBO_ATTRIB_MAX) ATTR3F(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
1253 }
1254
1255 static void GLAPIENTRY
TAG(VertexAttrib4svNV)1256 TAG(VertexAttrib4svNV)(GLuint index, const GLshort *v)
1257 {
1258 GET_CURRENT_CONTEXT(ctx);
1259 if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2],
1260 (GLfloat)v[3]);
1261 }
1262
1263 static void GLAPIENTRY
TAG(VertexAttrib4dvNV)1264 TAG(VertexAttrib4dvNV)(GLuint index, const GLdouble *v)
1265 {
1266 GET_CURRENT_CONTEXT(ctx);
1267 if (index < VBO_ATTRIB_MAX) ATTR4F(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
1268 }
1269
1270 static void GLAPIENTRY
TAG(VertexAttrib4ubvNV)1271 TAG(VertexAttrib4ubvNV)(GLuint index, const GLubyte *v)
1272 {
1273 GET_CURRENT_CONTEXT(ctx);
1274 if (index < VBO_ATTRIB_MAX) ATTR4F(index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]),
1275 UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3]));
1276 }
1277
1278
1279 static void GLAPIENTRY
TAG(VertexAttribs1svNV)1280 TAG(VertexAttribs1svNV)(GLuint index, GLsizei n, const GLshort *v)
1281 {
1282 GET_CURRENT_CONTEXT(ctx);
1283 GLint i;
1284 n = MIN2(n, VBO_ATTRIB_MAX - index);
1285 for (i = n - 1; i >= 0; i--)
1286 ATTR1F(index + i, (GLfloat) v[i]);
1287 }
1288
1289 static void GLAPIENTRY
TAG(VertexAttribs1fvNV)1290 TAG(VertexAttribs1fvNV)(GLuint index, GLsizei n, const GLfloat *v)
1291 {
1292 GET_CURRENT_CONTEXT(ctx);
1293 GLint i;
1294 n = MIN2(n, VBO_ATTRIB_MAX - index);
1295 for (i = n - 1; i >= 0; i--)
1296 ATTR1F(index + i, v[i]);
1297 }
1298
1299 static void GLAPIENTRY
TAG(VertexAttribs1dvNV)1300 TAG(VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble *v)
1301 {
1302 GET_CURRENT_CONTEXT(ctx);
1303 GLint i;
1304 n = MIN2(n, VBO_ATTRIB_MAX - index);
1305 for (i = n - 1; i >= 0; i--)
1306 ATTR1F(index + i, (GLfloat) v[i]);
1307 }
1308
1309 static void GLAPIENTRY
TAG(VertexAttribs2svNV)1310 TAG(VertexAttribs2svNV)(GLuint index, GLsizei n, const GLshort *v)
1311 {
1312 GET_CURRENT_CONTEXT(ctx);
1313 GLint i;
1314 n = MIN2(n, VBO_ATTRIB_MAX - index);
1315 for (i = n - 1; i >= 0; i--)
1316 ATTR2F(index + i, (GLfloat) v[2 * i], (GLfloat) v[2 * i + 1]);
1317 }
1318
1319 static void GLAPIENTRY
TAG(VertexAttribs2fvNV)1320 TAG(VertexAttribs2fvNV)(GLuint index, GLsizei n, const GLfloat *v)
1321 {
1322 GET_CURRENT_CONTEXT(ctx);
1323 GLint i;
1324 n = MIN2(n, VBO_ATTRIB_MAX - index);
1325 for (i = n - 1; i >= 0; i--)
1326 ATTR2F(index + i, v[2 * i], v[2 * i + 1]);
1327 }
1328
1329 static void GLAPIENTRY
TAG(VertexAttribs2dvNV)1330 TAG(VertexAttribs2dvNV)(GLuint index, GLsizei n, const GLdouble *v)
1331 {
1332 GET_CURRENT_CONTEXT(ctx);
1333 GLint i;
1334 n = MIN2(n, VBO_ATTRIB_MAX - index);
1335 for (i = n - 1; i >= 0; i--)
1336 ATTR2F(index + i, (GLfloat) v[2 * i], (GLfloat) v[2 * i + 1]);
1337 }
1338
1339 static void GLAPIENTRY
TAG(VertexAttribs3svNV)1340 TAG(VertexAttribs3svNV)(GLuint index, GLsizei n, const GLshort *v)
1341 {
1342 GET_CURRENT_CONTEXT(ctx);
1343 GLint i;
1344 n = MIN2(n, VBO_ATTRIB_MAX - index);
1345 for (i = n - 1; i >= 0; i--)
1346 ATTR3F(index + i, (GLfloat) v[3 * i], (GLfloat) v[3 * i + 1], (GLfloat) v[3 * i + 2]);
1347 }
1348
1349 static void GLAPIENTRY
TAG(VertexAttribs3fvNV)1350 TAG(VertexAttribs3fvNV)(GLuint index, GLsizei n, const GLfloat *v)
1351 {
1352 GET_CURRENT_CONTEXT(ctx);
1353 GLint i;
1354 n = MIN2(n, VBO_ATTRIB_MAX - index);
1355 for (i = n - 1; i >= 0; i--)
1356 ATTR3F(index + i, v[3 * i], v[3 * i + 1], v[3 * i + 2]);
1357 }
1358
1359 static void GLAPIENTRY
TAG(VertexAttribs3dvNV)1360 TAG(VertexAttribs3dvNV)(GLuint index, GLsizei n, const GLdouble *v)
1361 {
1362 GET_CURRENT_CONTEXT(ctx);
1363 GLint i;
1364 n = MIN2(n, VBO_ATTRIB_MAX - index);
1365 for (i = n - 1; i >= 0; i--)
1366 ATTR3F(index + i, (GLfloat) v[3 * i], (GLfloat) v[3 * i + 1], (GLfloat) v[3 * i + 2]);
1367 }
1368
1369 static void GLAPIENTRY
TAG(VertexAttribs4svNV)1370 TAG(VertexAttribs4svNV)(GLuint index, GLsizei n, const GLshort *v)
1371 {
1372 GET_CURRENT_CONTEXT(ctx);
1373 GLint i;
1374 n = MIN2(n, VBO_ATTRIB_MAX - index);
1375 for (i = n - 1; i >= 0; i--)
1376 ATTR4F(index + i, (GLfloat) v[4 * i], (GLfloat) v[4 * i + 1], (GLfloat) v[4 * i + 2], (GLfloat) v[4 * i + 3]);
1377 }
1378
1379 static void GLAPIENTRY
TAG(VertexAttribs4fvNV)1380 TAG(VertexAttribs4fvNV)(GLuint index, GLsizei n, const GLfloat *v)
1381 {
1382 GET_CURRENT_CONTEXT(ctx);
1383 GLint i;
1384 n = MIN2(n, VBO_ATTRIB_MAX - index);
1385 for (i = n - 1; i >= 0; i--)
1386 ATTR4F(index + i, v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3]);
1387 }
1388
1389 static void GLAPIENTRY
TAG(VertexAttribs4dvNV)1390 TAG(VertexAttribs4dvNV)(GLuint index, GLsizei n, const GLdouble *v)
1391 {
1392 GET_CURRENT_CONTEXT(ctx);
1393 GLint i;
1394 n = MIN2(n, VBO_ATTRIB_MAX - index);
1395 for (i = n - 1; i >= 0; i--)
1396 ATTR4F(index + i, (GLfloat) v[4 * i], (GLfloat) v[4 * i + 1], (GLfloat) v[4 * i + 2], (GLfloat) v[4 * i + 3]);
1397 }
1398
1399 static void GLAPIENTRY
TAG(VertexAttribs4ubvNV)1400 TAG(VertexAttribs4ubvNV)(GLuint index, GLsizei n, const GLubyte *v)
1401 {
1402 GET_CURRENT_CONTEXT(ctx);
1403 GLint i;
1404 n = MIN2(n, VBO_ATTRIB_MAX - index);
1405 for (i = n - 1; i >= 0; i--)
1406 ATTR4F(index + i, UBYTE_TO_FLOAT(v[4 * i]), UBYTE_TO_FLOAT(v[4 * i + 1]),
1407 UBYTE_TO_FLOAT(v[4 * i + 2]), UBYTE_TO_FLOAT(v[4 * i + 3]));
1408 }
1409
1410
1411 /*
1412 * GL_ARB_vertex_program
1413 * Note that attribute indexes do NOT alias conventional attributes.
1414 */
1415
1416 static void GLAPIENTRY
TAG(VertexAttrib1s)1417 TAG(VertexAttrib1s)(GLuint index, GLshort x)
1418 {
1419 GET_CURRENT_CONTEXT(ctx);
1420 if (is_vertex_position(ctx, index))
1421 ATTR1F(0, (GLfloat) x);
1422 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1423 ATTR1F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x);
1424 else
1425 ERROR(GL_INVALID_VALUE);
1426 }
1427
1428 static void GLAPIENTRY
TAG(VertexAttrib1d)1429 TAG(VertexAttrib1d)(GLuint index, GLdouble x)
1430 {
1431 GET_CURRENT_CONTEXT(ctx);
1432 if (is_vertex_position(ctx, index))
1433 ATTR1F(0, (GLfloat) x);
1434 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1435 ATTR1F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x);
1436 else
1437 ERROR(GL_INVALID_VALUE);
1438 }
1439
1440 static void GLAPIENTRY
TAG(VertexAttrib2s)1441 TAG(VertexAttrib2s)(GLuint index, GLshort x, GLshort y)
1442 {
1443 GET_CURRENT_CONTEXT(ctx);
1444 if (is_vertex_position(ctx, index))
1445 ATTR2F(0, (GLfloat) x, (GLfloat) y);
1446 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1447 ATTR2F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y);
1448 else
1449 ERROR(GL_INVALID_VALUE);
1450 }
1451
1452 static void GLAPIENTRY
TAG(VertexAttrib2d)1453 TAG(VertexAttrib2d)(GLuint index, GLdouble x, GLdouble y)
1454 {
1455 GET_CURRENT_CONTEXT(ctx);
1456 if (is_vertex_position(ctx, index))
1457 ATTR2F(0, (GLfloat) x, (GLfloat) y);
1458 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1459 ATTR2F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y);
1460 else
1461 ERROR(GL_INVALID_VALUE);
1462 }
1463
1464 static void GLAPIENTRY
TAG(VertexAttrib3s)1465 TAG(VertexAttrib3s)(GLuint index, GLshort x, GLshort y, GLshort z)
1466 {
1467 GET_CURRENT_CONTEXT(ctx);
1468 if (is_vertex_position(ctx, index))
1469 ATTR3F(0, (GLfloat) x, (GLfloat) y, (GLfloat) z);
1470 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1471 ATTR3F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y, (GLfloat) z);
1472 else
1473 ERROR(GL_INVALID_VALUE);
1474 }
1475
1476 static void GLAPIENTRY
TAG(VertexAttrib3d)1477 TAG(VertexAttrib3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z)
1478 {
1479 GET_CURRENT_CONTEXT(ctx);
1480 if (is_vertex_position(ctx, index))
1481 ATTR3F(0, (GLfloat) x, (GLfloat) y, (GLfloat) z);
1482 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1483 ATTR3F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y, (GLfloat) z);
1484 else
1485 ERROR(GL_INVALID_VALUE);
1486 }
1487
1488 static void GLAPIENTRY
TAG(VertexAttrib4s)1489 TAG(VertexAttrib4s)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
1490 {
1491 GET_CURRENT_CONTEXT(ctx);
1492 if (is_vertex_position(ctx, index))
1493 ATTR4F(0, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
1494 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1495 ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
1496 else
1497 ERROR(GL_INVALID_VALUE);
1498 }
1499
1500 static void GLAPIENTRY
TAG(VertexAttrib4d)1501 TAG(VertexAttrib4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1502 {
1503 GET_CURRENT_CONTEXT(ctx);
1504 if (is_vertex_position(ctx, index))
1505 ATTR4F(0, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
1506 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1507 ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
1508 else
1509 ERROR(GL_INVALID_VALUE);
1510 }
1511
1512 static void GLAPIENTRY
TAG(VertexAttrib1sv)1513 TAG(VertexAttrib1sv)(GLuint index, const GLshort *v)
1514 {
1515 GET_CURRENT_CONTEXT(ctx);
1516 if (is_vertex_position(ctx, index))
1517 ATTR1F(0, (GLfloat) v[0]);
1518 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1519 ATTR1F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0]);
1520 else
1521 ERROR(GL_INVALID_VALUE);
1522 }
1523
1524 static void GLAPIENTRY
TAG(VertexAttrib1dv)1525 TAG(VertexAttrib1dv)(GLuint index, const GLdouble *v)
1526 {
1527 GET_CURRENT_CONTEXT(ctx);
1528 if (is_vertex_position(ctx, index))
1529 ATTR1F(0, (GLfloat) v[0]);
1530 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1531 ATTR1F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0]);
1532 else
1533 ERROR(GL_INVALID_VALUE);
1534 }
1535
1536 static void GLAPIENTRY
TAG(VertexAttrib2sv)1537 TAG(VertexAttrib2sv)(GLuint index, const GLshort *v)
1538 {
1539 GET_CURRENT_CONTEXT(ctx);
1540 if (is_vertex_position(ctx, index))
1541 ATTR2F(0, (GLfloat) v[0], (GLfloat) v[1]);
1542 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1543 ATTR2F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1]);
1544 else
1545 ERROR(GL_INVALID_VALUE);
1546 }
1547
1548 static void GLAPIENTRY
TAG(VertexAttrib2dv)1549 TAG(VertexAttrib2dv)(GLuint index, const GLdouble *v)
1550 {
1551 GET_CURRENT_CONTEXT(ctx);
1552 if (is_vertex_position(ctx, index))
1553 ATTR2F(0, (GLfloat) v[0], (GLfloat) v[1]);
1554 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1555 ATTR2F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1]);
1556 else
1557 ERROR(GL_INVALID_VALUE);
1558 }
1559
1560 static void GLAPIENTRY
TAG(VertexAttrib3sv)1561 TAG(VertexAttrib3sv)(GLuint index, const GLshort *v)
1562 {
1563 GET_CURRENT_CONTEXT(ctx);
1564 if (is_vertex_position(ctx, index))
1565 ATTR3F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
1566 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1567 ATTR3F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
1568 else
1569 ERROR(GL_INVALID_VALUE);
1570 }
1571
1572 static void GLAPIENTRY
TAG(VertexAttrib3dv)1573 TAG(VertexAttrib3dv)(GLuint index, const GLdouble *v)
1574 {
1575 GET_CURRENT_CONTEXT(ctx);
1576 if (is_vertex_position(ctx, index))
1577 ATTR3F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
1578 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1579 ATTR3F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
1580 else
1581 ERROR(GL_INVALID_VALUE);
1582 }
1583
1584 static void GLAPIENTRY
TAG(VertexAttrib4sv)1585 TAG(VertexAttrib4sv)(GLuint index, const GLshort *v)
1586 {
1587 GET_CURRENT_CONTEXT(ctx);
1588 if (is_vertex_position(ctx, index))
1589 ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1590 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1591 ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1592 else
1593 ERROR(GL_INVALID_VALUE);
1594 }
1595
1596 static void GLAPIENTRY
TAG(VertexAttrib4dv)1597 TAG(VertexAttrib4dv)(GLuint index, const GLdouble *v)
1598 {
1599 GET_CURRENT_CONTEXT(ctx);
1600 if (is_vertex_position(ctx, index))
1601 ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1602 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1603 ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1604 else
1605 ERROR(GL_INVALID_VALUE);
1606 }
1607
1608 static void GLAPIENTRY
TAG(VertexAttrib4bv)1609 TAG(VertexAttrib4bv)(GLuint index, const GLbyte * v)
1610 {
1611 GET_CURRENT_CONTEXT(ctx);
1612 if (is_vertex_position(ctx, index))
1613 ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1614 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1615 ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1616 else
1617 ERROR(GL_INVALID_VALUE);
1618 }
1619
1620 static void GLAPIENTRY
TAG(VertexAttrib4iv)1621 TAG(VertexAttrib4iv)(GLuint index, const GLint * v)
1622 {
1623 GET_CURRENT_CONTEXT(ctx);
1624 if (is_vertex_position(ctx, index))
1625 ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1626 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1627 ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1628 else
1629 ERROR(GL_INVALID_VALUE);
1630 }
1631
1632 static void GLAPIENTRY
TAG(VertexAttrib4ubv)1633 TAG(VertexAttrib4ubv)(GLuint index, const GLubyte * v)
1634 {
1635 GET_CURRENT_CONTEXT(ctx);
1636 if (is_vertex_position(ctx, index))
1637 ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1638 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1639 ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1640 else
1641 ERROR(GL_INVALID_VALUE);
1642 }
1643
1644 static void GLAPIENTRY
TAG(VertexAttrib4usv)1645 TAG(VertexAttrib4usv)(GLuint index, const GLushort * v)
1646 {
1647 GET_CURRENT_CONTEXT(ctx);
1648 if (is_vertex_position(ctx, index))
1649 ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1650 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1651 ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1652 else
1653 ERROR(GL_INVALID_VALUE);
1654 }
1655
1656 static void GLAPIENTRY
TAG(VertexAttrib4uiv)1657 TAG(VertexAttrib4uiv)(GLuint index, const GLuint * v)
1658 {
1659 GET_CURRENT_CONTEXT(ctx);
1660 if (is_vertex_position(ctx, index))
1661 ATTR4F(0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1662 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1663 ATTR4F(VBO_ATTRIB_GENERIC0 + index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]);
1664 else
1665 ERROR(GL_INVALID_VALUE);
1666 }
1667
1668 static void GLAPIENTRY
TAG(VertexAttrib4Nbv)1669 TAG(VertexAttrib4Nbv)(GLuint index, const GLbyte * v)
1670 {
1671 GET_CURRENT_CONTEXT(ctx);
1672 if (is_vertex_position(ctx, index))
1673 ATTR4F(0, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]));
1674 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1675 ATTR4F(VBO_ATTRIB_GENERIC0 + index, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]));
1676 else
1677 ERROR(GL_INVALID_VALUE);
1678 }
1679
1680 static void GLAPIENTRY
TAG(VertexAttrib4Nsv)1681 TAG(VertexAttrib4Nsv)(GLuint index, const GLshort * v)
1682 {
1683 GET_CURRENT_CONTEXT(ctx);
1684 if (is_vertex_position(ctx, index))
1685 ATTR4F(0, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]));
1686 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1687 ATTR4F(VBO_ATTRIB_GENERIC0 + index, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]));
1688 else
1689 ERROR(GL_INVALID_VALUE);
1690 }
1691
1692 static void GLAPIENTRY
TAG(VertexAttrib4Niv)1693 TAG(VertexAttrib4Niv)(GLuint index, const GLint * v)
1694 {
1695 GET_CURRENT_CONTEXT(ctx);
1696 if (is_vertex_position(ctx, index))
1697 ATTR4F(0, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]));
1698 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1699 ATTR4F(VBO_ATTRIB_GENERIC0 + index, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]));
1700 else
1701 ERROR(GL_INVALID_VALUE);
1702 }
1703
1704 static void GLAPIENTRY
TAG(VertexAttrib4Nub)1705 TAG(VertexAttrib4Nub)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
1706 {
1707 GET_CURRENT_CONTEXT(ctx);
1708 if (is_vertex_position(ctx, index))
1709 ATTR4F(0, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y), UBYTE_TO_FLOAT(z), UBYTE_TO_FLOAT(w));
1710 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1711 ATTR4F(VBO_ATTRIB_GENERIC0 + index, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y), UBYTE_TO_FLOAT(z), UBYTE_TO_FLOAT(w));
1712 else
1713 ERROR(GL_INVALID_VALUE);
1714 }
1715
1716 static void GLAPIENTRY
TAG(VertexAttrib4Nubv)1717 TAG(VertexAttrib4Nubv)(GLuint index, const GLubyte * v)
1718 {
1719 GET_CURRENT_CONTEXT(ctx);
1720 if (is_vertex_position(ctx, index))
1721 ATTR4F(0, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]), UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3]));
1722 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1723 ATTR4F(VBO_ATTRIB_GENERIC0 + index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]), UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3]));
1724 else
1725 ERROR(GL_INVALID_VALUE);
1726 }
1727
1728 static void GLAPIENTRY
TAG(VertexAttrib4Nusv)1729 TAG(VertexAttrib4Nusv)(GLuint index, const GLushort * v)
1730 {
1731 GET_CURRENT_CONTEXT(ctx);
1732 if (is_vertex_position(ctx, index))
1733 ATTR4F(0, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]), USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]));
1734 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1735 ATTR4F(VBO_ATTRIB_GENERIC0 + index, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]), USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]));
1736 else
1737 ERROR(GL_INVALID_VALUE);
1738 }
1739
1740 static void GLAPIENTRY
TAG(VertexAttrib4Nuiv)1741 TAG(VertexAttrib4Nuiv)(GLuint index, const GLuint * v)
1742 {
1743 GET_CURRENT_CONTEXT(ctx);
1744 if (is_vertex_position(ctx, index))
1745 ATTR4F(0, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]), UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]));
1746 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1747 ATTR4F(VBO_ATTRIB_GENERIC0 + index, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]), UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]));
1748 else
1749 ERROR(GL_INVALID_VALUE);
1750 }
1751
1752 /**
1753 * GL_EXT_gpu_shader / GL 3.0 signed/unsigned integer-valued attributes.
1754 * Note that attribute indexes do NOT alias conventional attributes.
1755 */
1756
1757 static void GLAPIENTRY
TAG(VertexAttribI1iv)1758 TAG(VertexAttribI1iv)(GLuint index, const GLint *v)
1759 {
1760 GET_CURRENT_CONTEXT(ctx);
1761 if (is_vertex_position(ctx, index))
1762 ATTR1I(0, v[0]);
1763 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1764 ATTR1I(VBO_ATTRIB_GENERIC0 + index, v[0]);
1765 else
1766 ERROR(GL_INVALID_VALUE);
1767 }
1768
1769 static void GLAPIENTRY
TAG(VertexAttribI1uiv)1770 TAG(VertexAttribI1uiv)(GLuint index, const GLuint *v)
1771 {
1772 GET_CURRENT_CONTEXT(ctx);
1773 if (is_vertex_position(ctx, index))
1774 ATTR1UI(0, v[0]);
1775 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1776 ATTR1UI(VBO_ATTRIB_GENERIC0 + index, v[0]);
1777 else
1778 ERROR(GL_INVALID_VALUE);
1779 }
1780
1781 static void GLAPIENTRY
TAG(VertexAttribI4bv)1782 TAG(VertexAttribI4bv)(GLuint index, const GLbyte *v)
1783 {
1784 GET_CURRENT_CONTEXT(ctx);
1785 if (is_vertex_position(ctx, index))
1786 ATTR4I(0, v[0], v[1], v[2], v[3]);
1787 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1788 ATTR4I(VBO_ATTRIB_GENERIC0 + index, v[0], v[1], v[2], v[3]);
1789 else
1790 ERROR(GL_INVALID_VALUE);
1791 }
1792
1793 static void GLAPIENTRY
TAG(VertexAttribI4sv)1794 TAG(VertexAttribI4sv)(GLuint index, const GLshort *v)
1795 {
1796 GET_CURRENT_CONTEXT(ctx);
1797 if (is_vertex_position(ctx, index))
1798 ATTR4I(0, v[0], v[1], v[2], v[3]);
1799 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1800 ATTR4I(VBO_ATTRIB_GENERIC0 + index, v[0], v[1], v[2], v[3]);
1801 else
1802 ERROR(GL_INVALID_VALUE);
1803 }
1804
1805 static void GLAPIENTRY
TAG(VertexAttribI4ubv)1806 TAG(VertexAttribI4ubv)(GLuint index, const GLubyte *v)
1807 {
1808 GET_CURRENT_CONTEXT(ctx);
1809 if (is_vertex_position(ctx, index))
1810 ATTR4UI(0, v[0], v[1], v[2], v[3]);
1811 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1812 ATTR4UI(VBO_ATTRIB_GENERIC0 + index, v[0], v[1], v[2], v[3]);
1813 else
1814 ERROR(GL_INVALID_VALUE);
1815 }
1816
1817 static void GLAPIENTRY
TAG(VertexAttribI4usv)1818 TAG(VertexAttribI4usv)(GLuint index, const GLushort *v)
1819 {
1820 GET_CURRENT_CONTEXT(ctx);
1821 if (is_vertex_position(ctx, index))
1822 ATTR4UI(0, v[0], v[1], v[2], v[3]);
1823 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1824 ATTR4UI(VBO_ATTRIB_GENERIC0 + index, v[0], v[1], v[2], v[3]);
1825 else
1826 ERROR(GL_INVALID_VALUE);
1827 }
1828
1829 /* define this macro to exclude folllowing none-vertex functions */
1830 #ifndef HW_SELECT_MODE
1831
1832 static void GLAPIENTRY
TAG(TexCoord1f)1833 TAG(TexCoord1f)(GLfloat x)
1834 {
1835 GET_CURRENT_CONTEXT(ctx);
1836 ATTR1F(VBO_ATTRIB_TEX0, x);
1837 }
1838
1839 static void GLAPIENTRY
TAG(TexCoord1fv)1840 TAG(TexCoord1fv)(const GLfloat * v)
1841 {
1842 GET_CURRENT_CONTEXT(ctx);
1843 ATTR1FV(VBO_ATTRIB_TEX0, v);
1844 }
1845
1846 static void GLAPIENTRY
TAG(TexCoord2f)1847 TAG(TexCoord2f)(GLfloat x, GLfloat y)
1848 {
1849 GET_CURRENT_CONTEXT(ctx);
1850 ATTR2F(VBO_ATTRIB_TEX0, x, y);
1851 }
1852
1853 static void GLAPIENTRY
TAG(TexCoord2fv)1854 TAG(TexCoord2fv)(const GLfloat * v)
1855 {
1856 GET_CURRENT_CONTEXT(ctx);
1857 ATTR2FV(VBO_ATTRIB_TEX0, v);
1858 }
1859
1860 static void GLAPIENTRY
TAG(TexCoord3f)1861 TAG(TexCoord3f)(GLfloat x, GLfloat y, GLfloat z)
1862 {
1863 GET_CURRENT_CONTEXT(ctx);
1864 ATTR3F(VBO_ATTRIB_TEX0, x, y, z);
1865 }
1866
1867 static void GLAPIENTRY
TAG(TexCoord3fv)1868 TAG(TexCoord3fv)(const GLfloat * v)
1869 {
1870 GET_CURRENT_CONTEXT(ctx);
1871 ATTR3FV(VBO_ATTRIB_TEX0, v);
1872 }
1873
1874 static void GLAPIENTRY
TAG(TexCoord4f)1875 TAG(TexCoord4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1876 {
1877 GET_CURRENT_CONTEXT(ctx);
1878 ATTR4F(VBO_ATTRIB_TEX0, x, y, z, w);
1879 }
1880
1881 static void GLAPIENTRY
TAG(TexCoord4fv)1882 TAG(TexCoord4fv)(const GLfloat * v)
1883 {
1884 GET_CURRENT_CONTEXT(ctx);
1885 ATTR4FV(VBO_ATTRIB_TEX0, v);
1886 }
1887
1888
1889
1890 static void GLAPIENTRY
TAG(Normal3f)1891 TAG(Normal3f)(GLfloat x, GLfloat y, GLfloat z)
1892 {
1893 GET_CURRENT_CONTEXT(ctx);
1894 ATTR3F(VBO_ATTRIB_NORMAL, x, y, z);
1895 }
1896
1897 static void GLAPIENTRY
TAG(Normal3fv)1898 TAG(Normal3fv)(const GLfloat * v)
1899 {
1900 GET_CURRENT_CONTEXT(ctx);
1901 ATTR3FV(VBO_ATTRIB_NORMAL, v);
1902 }
1903
1904
1905
1906 static void GLAPIENTRY
TAG(FogCoordfEXT)1907 TAG(FogCoordfEXT)(GLfloat x)
1908 {
1909 GET_CURRENT_CONTEXT(ctx);
1910 ATTR1F(VBO_ATTRIB_FOG, x);
1911 }
1912
1913
1914
1915 static void GLAPIENTRY
TAG(FogCoordfvEXT)1916 TAG(FogCoordfvEXT)(const GLfloat * v)
1917 {
1918 GET_CURRENT_CONTEXT(ctx);
1919 ATTR1FV(VBO_ATTRIB_FOG, v);
1920 }
1921
1922 static void GLAPIENTRY
TAG(Color3f)1923 TAG(Color3f)(GLfloat x, GLfloat y, GLfloat z)
1924 {
1925 GET_CURRENT_CONTEXT(ctx);
1926 ATTR3F(VBO_ATTRIB_COLOR0, x, y, z);
1927 }
1928
1929 static void GLAPIENTRY
TAG(Color3fv)1930 TAG(Color3fv)(const GLfloat * v)
1931 {
1932 GET_CURRENT_CONTEXT(ctx);
1933 ATTR3FV(VBO_ATTRIB_COLOR0, v);
1934 }
1935
1936 static void GLAPIENTRY
TAG(Color4f)1937 TAG(Color4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1938 {
1939 GET_CURRENT_CONTEXT(ctx);
1940 ATTR4F(VBO_ATTRIB_COLOR0, x, y, z, w);
1941 }
1942
1943 static void GLAPIENTRY
TAG(Color4fv)1944 TAG(Color4fv)(const GLfloat * v)
1945 {
1946 GET_CURRENT_CONTEXT(ctx);
1947 ATTR4FV(VBO_ATTRIB_COLOR0, v);
1948 }
1949
1950
1951
1952 static void GLAPIENTRY
TAG(SecondaryColor3fEXT)1953 TAG(SecondaryColor3fEXT)(GLfloat x, GLfloat y, GLfloat z)
1954 {
1955 GET_CURRENT_CONTEXT(ctx);
1956 ATTR3F(VBO_ATTRIB_COLOR1, x, y, z);
1957 }
1958
1959 static void GLAPIENTRY
TAG(SecondaryColor3fvEXT)1960 TAG(SecondaryColor3fvEXT)(const GLfloat * v)
1961 {
1962 GET_CURRENT_CONTEXT(ctx);
1963 ATTR3FV(VBO_ATTRIB_COLOR1, v);
1964 }
1965
1966
1967
1968 static void GLAPIENTRY
TAG(EdgeFlag)1969 TAG(EdgeFlag)(GLboolean b)
1970 {
1971 GET_CURRENT_CONTEXT(ctx);
1972 ATTR1F(VBO_ATTRIB_EDGEFLAG, (GLfloat) b);
1973 }
1974
1975
1976
1977 static void GLAPIENTRY
TAG(Indexf)1978 TAG(Indexf)(GLfloat f)
1979 {
1980 GET_CURRENT_CONTEXT(ctx);
1981 ATTR1F(VBO_ATTRIB_COLOR_INDEX, f);
1982 }
1983
1984 static void GLAPIENTRY
TAG(Indexfv)1985 TAG(Indexfv)(const GLfloat * f)
1986 {
1987 GET_CURRENT_CONTEXT(ctx);
1988 ATTR1FV(VBO_ATTRIB_COLOR_INDEX, f);
1989 }
1990
1991
1992
1993 static void GLAPIENTRY
TAG(MultiTexCoord1fARB)1994 TAG(MultiTexCoord1fARB)(GLenum target, GLfloat x)
1995 {
1996 GET_CURRENT_CONTEXT(ctx);
1997 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
1998 ATTR1F(attr, x);
1999 }
2000
2001 static void GLAPIENTRY
TAG(MultiTexCoord1fvARB)2002 TAG(MultiTexCoord1fvARB)(GLenum target, const GLfloat * v)
2003 {
2004 GET_CURRENT_CONTEXT(ctx);
2005 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2006 ATTR1FV(attr, v);
2007 }
2008
2009 static void GLAPIENTRY
TAG(MultiTexCoord2fARB)2010 TAG(MultiTexCoord2fARB)(GLenum target, GLfloat x, GLfloat y)
2011 {
2012 GET_CURRENT_CONTEXT(ctx);
2013 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2014 ATTR2F(attr, x, y);
2015 }
2016
2017 static void GLAPIENTRY
TAG(MultiTexCoord2fvARB)2018 TAG(MultiTexCoord2fvARB)(GLenum target, const GLfloat * v)
2019 {
2020 GET_CURRENT_CONTEXT(ctx);
2021 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2022 ATTR2FV(attr, v);
2023 }
2024
2025 static void GLAPIENTRY
TAG(MultiTexCoord3fARB)2026 TAG(MultiTexCoord3fARB)(GLenum target, GLfloat x, GLfloat y, GLfloat z)
2027 {
2028 GET_CURRENT_CONTEXT(ctx);
2029 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2030 ATTR3F(attr, x, y, z);
2031 }
2032
2033 static void GLAPIENTRY
TAG(MultiTexCoord3fvARB)2034 TAG(MultiTexCoord3fvARB)(GLenum target, const GLfloat * v)
2035 {
2036 GET_CURRENT_CONTEXT(ctx);
2037 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2038 ATTR3FV(attr, v);
2039 }
2040
2041 static void GLAPIENTRY
TAG(MultiTexCoord4fARB)2042 TAG(MultiTexCoord4fARB)(GLenum target, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2043 {
2044 GET_CURRENT_CONTEXT(ctx);
2045 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2046 ATTR4F(attr, x, y, z, w);
2047 }
2048
2049 static void GLAPIENTRY
TAG(MultiTexCoord4fvARB)2050 TAG(MultiTexCoord4fvARB)(GLenum target, const GLfloat * v)
2051 {
2052 GET_CURRENT_CONTEXT(ctx);
2053 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2054 ATTR4FV(attr, v);
2055 }
2056
2057 static void GLAPIENTRY
TAG(TexCoordP1ui)2058 TAG(TexCoordP1ui)(GLenum type, GLuint coords)
2059 {
2060 GET_CURRENT_CONTEXT(ctx);
2061 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP1ui");
2062 ATTR_UI(ctx, 1, type, 0, VBO_ATTRIB_TEX0, coords);
2063 }
2064
2065 static void GLAPIENTRY
TAG(TexCoordP1uiv)2066 TAG(TexCoordP1uiv)(GLenum type, const GLuint *coords)
2067 {
2068 GET_CURRENT_CONTEXT(ctx);
2069 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP1uiv");
2070 ATTR_UI(ctx, 1, type, 0, VBO_ATTRIB_TEX0, coords[0]);
2071 }
2072
2073 static void GLAPIENTRY
TAG(TexCoordP2ui)2074 TAG(TexCoordP2ui)(GLenum type, GLuint coords)
2075 {
2076 GET_CURRENT_CONTEXT(ctx);
2077 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP2ui");
2078 ATTR_UI(ctx, 2, type, 0, VBO_ATTRIB_TEX0, coords);
2079 }
2080
2081 static void GLAPIENTRY
TAG(TexCoordP2uiv)2082 TAG(TexCoordP2uiv)(GLenum type, const GLuint *coords)
2083 {
2084 GET_CURRENT_CONTEXT(ctx);
2085 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP2uiv");
2086 ATTR_UI(ctx, 2, type, 0, VBO_ATTRIB_TEX0, coords[0]);
2087 }
2088
2089 static void GLAPIENTRY
TAG(TexCoordP3ui)2090 TAG(TexCoordP3ui)(GLenum type, GLuint coords)
2091 {
2092 GET_CURRENT_CONTEXT(ctx);
2093 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP3ui");
2094 ATTR_UI(ctx, 3, type, 0, VBO_ATTRIB_TEX0, coords);
2095 }
2096
2097 static void GLAPIENTRY
TAG(TexCoordP3uiv)2098 TAG(TexCoordP3uiv)(GLenum type, const GLuint *coords)
2099 {
2100 GET_CURRENT_CONTEXT(ctx);
2101 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP3uiv");
2102 ATTR_UI(ctx, 3, type, 0, VBO_ATTRIB_TEX0, coords[0]);
2103 }
2104
2105 static void GLAPIENTRY
TAG(TexCoordP4ui)2106 TAG(TexCoordP4ui)(GLenum type, GLuint coords)
2107 {
2108 GET_CURRENT_CONTEXT(ctx);
2109 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP4ui");
2110 ATTR_UI(ctx, 4, type, 0, VBO_ATTRIB_TEX0, coords);
2111 }
2112
2113 static void GLAPIENTRY
TAG(TexCoordP4uiv)2114 TAG(TexCoordP4uiv)(GLenum type, const GLuint *coords)
2115 {
2116 GET_CURRENT_CONTEXT(ctx);
2117 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP4uiv");
2118 ATTR_UI(ctx, 4, type, 0, VBO_ATTRIB_TEX0, coords[0]);
2119 }
2120
2121 static void GLAPIENTRY
TAG(MultiTexCoordP1ui)2122 TAG(MultiTexCoordP1ui)(GLenum target, GLenum type, GLuint coords)
2123 {
2124 GET_CURRENT_CONTEXT(ctx);
2125 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2126 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP1ui");
2127 ATTR_UI(ctx, 1, type, 0, attr, coords);
2128 }
2129
2130 static void GLAPIENTRY
TAG(MultiTexCoordP1uiv)2131 TAG(MultiTexCoordP1uiv)(GLenum target, GLenum type, const GLuint *coords)
2132 {
2133 GET_CURRENT_CONTEXT(ctx);
2134 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2135 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP1uiv");
2136 ATTR_UI(ctx, 1, type, 0, attr, coords[0]);
2137 }
2138
2139 static void GLAPIENTRY
TAG(MultiTexCoordP2ui)2140 TAG(MultiTexCoordP2ui)(GLenum target, GLenum type, GLuint coords)
2141 {
2142 GET_CURRENT_CONTEXT(ctx);
2143 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2144 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP2ui");
2145 ATTR_UI(ctx, 2, type, 0, attr, coords);
2146 }
2147
2148 static void GLAPIENTRY
TAG(MultiTexCoordP2uiv)2149 TAG(MultiTexCoordP2uiv)(GLenum target, GLenum type, const GLuint *coords)
2150 {
2151 GET_CURRENT_CONTEXT(ctx);
2152 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2153 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP2uiv");
2154 ATTR_UI(ctx, 2, type, 0, attr, coords[0]);
2155 }
2156
2157 static void GLAPIENTRY
TAG(MultiTexCoordP3ui)2158 TAG(MultiTexCoordP3ui)(GLenum target, GLenum type, GLuint coords)
2159 {
2160 GET_CURRENT_CONTEXT(ctx);
2161 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2162 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP3ui");
2163 ATTR_UI(ctx, 3, type, 0, attr, coords);
2164 }
2165
2166 static void GLAPIENTRY
TAG(MultiTexCoordP3uiv)2167 TAG(MultiTexCoordP3uiv)(GLenum target, GLenum type, const GLuint *coords)
2168 {
2169 GET_CURRENT_CONTEXT(ctx);
2170 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2171 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP3uiv");
2172 ATTR_UI(ctx, 3, type, 0, attr, coords[0]);
2173 }
2174
2175 static void GLAPIENTRY
TAG(MultiTexCoordP4ui)2176 TAG(MultiTexCoordP4ui)(GLenum target, GLenum type, GLuint coords)
2177 {
2178 GET_CURRENT_CONTEXT(ctx);
2179 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2180 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP4ui");
2181 ATTR_UI(ctx, 4, type, 0, attr, coords);
2182 }
2183
2184 static void GLAPIENTRY
TAG(MultiTexCoordP4uiv)2185 TAG(MultiTexCoordP4uiv)(GLenum target, GLenum type, const GLuint *coords)
2186 {
2187 GET_CURRENT_CONTEXT(ctx);
2188 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2189 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP4uiv");
2190 ATTR_UI(ctx, 4, type, 0, attr, coords[0]);
2191 }
2192
2193 static void GLAPIENTRY
TAG(NormalP3ui)2194 TAG(NormalP3ui)(GLenum type, GLuint coords)
2195 {
2196 GET_CURRENT_CONTEXT(ctx);
2197 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glNormalP3ui");
2198 ATTR_UI(ctx, 3, type, 1, VBO_ATTRIB_NORMAL, coords);
2199 }
2200
2201 static void GLAPIENTRY
TAG(NormalP3uiv)2202 TAG(NormalP3uiv)(GLenum type, const GLuint *coords)
2203 {
2204 GET_CURRENT_CONTEXT(ctx);
2205 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glNormalP3uiv");
2206 ATTR_UI(ctx, 3, type, 1, VBO_ATTRIB_NORMAL, coords[0]);
2207 }
2208
2209 static void GLAPIENTRY
TAG(ColorP3ui)2210 TAG(ColorP3ui)(GLenum type, GLuint color)
2211 {
2212 GET_CURRENT_CONTEXT(ctx);
2213 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glColorP3ui");
2214 ATTR_UI(ctx, 3, type, 1, VBO_ATTRIB_COLOR0, color);
2215 }
2216
2217 static void GLAPIENTRY
TAG(ColorP3uiv)2218 TAG(ColorP3uiv)(GLenum type, const GLuint *color)
2219 {
2220 GET_CURRENT_CONTEXT(ctx);
2221 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glColorP3uiv");
2222 ATTR_UI(ctx, 3, type, 1, VBO_ATTRIB_COLOR0, color[0]);
2223 }
2224
2225 static void GLAPIENTRY
TAG(ColorP4ui)2226 TAG(ColorP4ui)(GLenum type, GLuint color)
2227 {
2228 GET_CURRENT_CONTEXT(ctx);
2229 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glColorP4ui");
2230 ATTR_UI(ctx, 4, type, 1, VBO_ATTRIB_COLOR0, color);
2231 }
2232
2233 static void GLAPIENTRY
TAG(ColorP4uiv)2234 TAG(ColorP4uiv)(GLenum type, const GLuint *color)
2235 {
2236 GET_CURRENT_CONTEXT(ctx);
2237 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glColorP4uiv");
2238 ATTR_UI(ctx, 4, type, 1, VBO_ATTRIB_COLOR0, color[0]);
2239 }
2240
2241 static void GLAPIENTRY
TAG(SecondaryColorP3ui)2242 TAG(SecondaryColorP3ui)(GLenum type, GLuint color)
2243 {
2244 GET_CURRENT_CONTEXT(ctx);
2245 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glSecondaryColorP3ui");
2246 ATTR_UI(ctx, 3, type, 1, VBO_ATTRIB_COLOR1, color);
2247 }
2248
2249 static void GLAPIENTRY
TAG(SecondaryColorP3uiv)2250 TAG(SecondaryColorP3uiv)(GLenum type, const GLuint *color)
2251 {
2252 GET_CURRENT_CONTEXT(ctx);
2253 ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glSecondaryColorP3uiv");
2254 ATTR_UI(ctx, 3, type, 1, VBO_ATTRIB_COLOR1, color[0]);
2255 }
2256
2257 static void GLAPIENTRY
TAG(Normal3hNV)2258 TAG(Normal3hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z)
2259 {
2260 GET_CURRENT_CONTEXT(ctx);
2261 ATTR3H(VBO_ATTRIB_NORMAL, x, y, z);
2262 }
2263
2264 static void GLAPIENTRY
TAG(Normal3hvNV)2265 TAG(Normal3hvNV)(const GLhalfNV * v)
2266 {
2267 GET_CURRENT_CONTEXT(ctx);
2268 ATTR3HV(VBO_ATTRIB_NORMAL, v);
2269 }
2270
2271
2272
2273 static void GLAPIENTRY
TAG(Color3hNV)2274 TAG(Color3hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z)
2275 {
2276 GET_CURRENT_CONTEXT(ctx);
2277 ATTR3H(VBO_ATTRIB_COLOR0, x, y, z);
2278 }
2279
2280 static void GLAPIENTRY
TAG(Color3hvNV)2281 TAG(Color3hvNV)(const GLhalfNV * v)
2282 {
2283 GET_CURRENT_CONTEXT(ctx);
2284 ATTR3HV(VBO_ATTRIB_COLOR0, v);
2285 }
2286
2287 static void GLAPIENTRY
TAG(Color4hNV)2288 TAG(Color4hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
2289 {
2290 GET_CURRENT_CONTEXT(ctx);
2291 ATTR4H(VBO_ATTRIB_COLOR0, x, y, z, w);
2292 }
2293
2294 static void GLAPIENTRY
TAG(Color4hvNV)2295 TAG(Color4hvNV)(const GLhalfNV * v)
2296 {
2297 GET_CURRENT_CONTEXT(ctx);
2298 ATTR4HV(VBO_ATTRIB_COLOR0, v);
2299 }
2300
2301
2302
2303 static void GLAPIENTRY
TAG(TexCoord1hNV)2304 TAG(TexCoord1hNV)(GLhalfNV x)
2305 {
2306 GET_CURRENT_CONTEXT(ctx);
2307 ATTR1H(VBO_ATTRIB_TEX0, x);
2308 }
2309
2310 static void GLAPIENTRY
TAG(TexCoord1hvNV)2311 TAG(TexCoord1hvNV)(const GLhalfNV * v)
2312 {
2313 GET_CURRENT_CONTEXT(ctx);
2314 ATTR1HV(VBO_ATTRIB_TEX0, v);
2315 }
2316
2317 static void GLAPIENTRY
TAG(TexCoord2hNV)2318 TAG(TexCoord2hNV)(GLhalfNV x, GLhalfNV y)
2319 {
2320 GET_CURRENT_CONTEXT(ctx);
2321 ATTR2H(VBO_ATTRIB_TEX0, x, y);
2322 }
2323
2324 static void GLAPIENTRY
TAG(TexCoord2hvNV)2325 TAG(TexCoord2hvNV)(const GLhalfNV * v)
2326 {
2327 GET_CURRENT_CONTEXT(ctx);
2328 ATTR2HV(VBO_ATTRIB_TEX0, v);
2329 }
2330
2331 static void GLAPIENTRY
TAG(TexCoord3hNV)2332 TAG(TexCoord3hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z)
2333 {
2334 GET_CURRENT_CONTEXT(ctx);
2335 ATTR3H(VBO_ATTRIB_TEX0, x, y, z);
2336 }
2337
2338 static void GLAPIENTRY
TAG(TexCoord3hvNV)2339 TAG(TexCoord3hvNV)(const GLhalfNV * v)
2340 {
2341 GET_CURRENT_CONTEXT(ctx);
2342 ATTR3HV(VBO_ATTRIB_TEX0, v);
2343 }
2344
2345 static void GLAPIENTRY
TAG(TexCoord4hNV)2346 TAG(TexCoord4hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
2347 {
2348 GET_CURRENT_CONTEXT(ctx);
2349 ATTR4H(VBO_ATTRIB_TEX0, x, y, z, w);
2350 }
2351
2352 static void GLAPIENTRY
TAG(TexCoord4hvNV)2353 TAG(TexCoord4hvNV)(const GLhalfNV * v)
2354 {
2355 GET_CURRENT_CONTEXT(ctx);
2356 ATTR4HV(VBO_ATTRIB_TEX0, v);
2357 }
2358
2359
2360
2361 static void GLAPIENTRY
TAG(MultiTexCoord1hNV)2362 TAG(MultiTexCoord1hNV)(GLenum target, GLhalfNV x)
2363 {
2364 GET_CURRENT_CONTEXT(ctx);
2365 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2366 ATTR1H(attr, x);
2367 }
2368
2369 static void GLAPIENTRY
TAG(MultiTexCoord1hvNV)2370 TAG(MultiTexCoord1hvNV)(GLenum target, const GLhalfNV * v)
2371 {
2372 GET_CURRENT_CONTEXT(ctx);
2373 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2374 ATTR1HV(attr, v);
2375 }
2376
2377 static void GLAPIENTRY
TAG(MultiTexCoord2hNV)2378 TAG(MultiTexCoord2hNV)(GLenum target, GLhalfNV x, GLhalfNV y)
2379 {
2380 GET_CURRENT_CONTEXT(ctx);
2381 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2382 ATTR2H(attr, x, y);
2383 }
2384
2385 static void GLAPIENTRY
TAG(MultiTexCoord2hvNV)2386 TAG(MultiTexCoord2hvNV)(GLenum target, const GLhalfNV * v)
2387 {
2388 GET_CURRENT_CONTEXT(ctx);
2389 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2390 ATTR2HV(attr, v);
2391 }
2392
2393 static void GLAPIENTRY
TAG(MultiTexCoord3hNV)2394 TAG(MultiTexCoord3hNV)(GLenum target, GLhalfNV x, GLhalfNV y, GLhalfNV z)
2395 {
2396 GET_CURRENT_CONTEXT(ctx);
2397 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2398 ATTR3H(attr, x, y, z);
2399 }
2400
2401 static void GLAPIENTRY
TAG(MultiTexCoord3hvNV)2402 TAG(MultiTexCoord3hvNV)(GLenum target, const GLhalfNV * v)
2403 {
2404 GET_CURRENT_CONTEXT(ctx);
2405 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2406 ATTR3HV(attr, v);
2407 }
2408
2409 static void GLAPIENTRY
TAG(MultiTexCoord4hNV)2410 TAG(MultiTexCoord4hNV)(GLenum target, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
2411 {
2412 GET_CURRENT_CONTEXT(ctx);
2413 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2414 ATTR4H(attr, x, y, z, w);
2415 }
2416
2417 static void GLAPIENTRY
TAG(MultiTexCoord4hvNV)2418 TAG(MultiTexCoord4hvNV)(GLenum target, const GLhalfNV * v)
2419 {
2420 GET_CURRENT_CONTEXT(ctx);
2421 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2422 ATTR4HV(attr, v);
2423 }
2424
2425
2426 static void GLAPIENTRY
TAG(FogCoordhNV)2427 TAG(FogCoordhNV)(GLhalf x)
2428 {
2429 GET_CURRENT_CONTEXT(ctx);
2430 ATTR1H(VBO_ATTRIB_FOG, x);
2431 }
2432
2433 static void GLAPIENTRY
TAG(FogCoordhvNV)2434 TAG(FogCoordhvNV)(const GLhalf * v)
2435 {
2436 GET_CURRENT_CONTEXT(ctx);
2437 ATTR1HV(VBO_ATTRIB_FOG, v);
2438 }
2439
2440
2441
2442 static void GLAPIENTRY
TAG(SecondaryColor3hNV)2443 TAG(SecondaryColor3hNV)(GLhalfNV x, GLhalfNV y, GLhalfNV z)
2444 {
2445 GET_CURRENT_CONTEXT(ctx);
2446 ATTR3H(VBO_ATTRIB_COLOR1, x, y, z);
2447 }
2448
2449 static void GLAPIENTRY
TAG(SecondaryColor3hvNV)2450 TAG(SecondaryColor3hvNV)(const GLhalfNV * v)
2451 {
2452 GET_CURRENT_CONTEXT(ctx);
2453 ATTR3HV(VBO_ATTRIB_COLOR1, v);
2454 }
2455
2456
2457 static void GLAPIENTRY
TAG(Color3b)2458 TAG(Color3b)(GLbyte red, GLbyte green, GLbyte blue)
2459 {
2460 GET_CURRENT_CONTEXT(ctx);
2461 ATTR4F(VBO_ATTRIB_COLOR0, BYTE_TO_FLOAT(red),
2462 BYTE_TO_FLOAT(green),
2463 BYTE_TO_FLOAT(blue),
2464 1.0);
2465 }
2466
2467 static void GLAPIENTRY
TAG(Color3d)2468 TAG(Color3d)(GLdouble red, GLdouble green, GLdouble blue)
2469 {
2470 GET_CURRENT_CONTEXT(ctx);
2471 ATTR4F(VBO_ATTRIB_COLOR0, (GLfloat) red, (GLfloat) green, (GLfloat) blue, 1.0);
2472 }
2473
2474 static void GLAPIENTRY
TAG(Color3i)2475 TAG(Color3i)(GLint red, GLint green, GLint blue)
2476 {
2477 GET_CURRENT_CONTEXT(ctx);
2478 ATTR4F(VBO_ATTRIB_COLOR0, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
2479 INT_TO_FLOAT(blue), 1.0);
2480 }
2481
2482 static void GLAPIENTRY
TAG(Color3s)2483 TAG(Color3s)(GLshort red, GLshort green, GLshort blue)
2484 {
2485 GET_CURRENT_CONTEXT(ctx);
2486 ATTR4F(VBO_ATTRIB_COLOR0, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
2487 SHORT_TO_FLOAT(blue), 1.0);
2488 }
2489
2490 static void GLAPIENTRY
TAG(Color3ui)2491 TAG(Color3ui)(GLuint red, GLuint green, GLuint blue)
2492 {
2493 GET_CURRENT_CONTEXT(ctx);
2494 ATTR4F(VBO_ATTRIB_COLOR0, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
2495 UINT_TO_FLOAT(blue), 1.0);
2496 }
2497
2498 static void GLAPIENTRY
TAG(Color3us)2499 TAG(Color3us)(GLushort red, GLushort green, GLushort blue)
2500 {
2501 GET_CURRENT_CONTEXT(ctx);
2502 ATTR4F(VBO_ATTRIB_COLOR0, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
2503 USHORT_TO_FLOAT(blue), 1.0);
2504 }
2505
2506 static void GLAPIENTRY
TAG(Color3ub)2507 TAG(Color3ub)(GLubyte red, GLubyte green, GLubyte blue)
2508 {
2509 GET_CURRENT_CONTEXT(ctx);
2510 ATTR4F(VBO_ATTRIB_COLOR0, UBYTE_TO_FLOAT(red), UBYTE_TO_FLOAT(green),
2511 UBYTE_TO_FLOAT(blue), 1.0);
2512 }
2513
2514
2515 static void GLAPIENTRY
TAG(Color3bv)2516 TAG(Color3bv)(const GLbyte *v)
2517 {
2518 GET_CURRENT_CONTEXT(ctx);
2519 ATTR4F(VBO_ATTRIB_COLOR0, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
2520 BYTE_TO_FLOAT(v[2]), 1.0);
2521 }
2522
2523 static void GLAPIENTRY
TAG(Color3dv)2524 TAG(Color3dv)(const GLdouble *v)
2525 {
2526 GET_CURRENT_CONTEXT(ctx);
2527 ATTR4F(VBO_ATTRIB_COLOR0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0);
2528 }
2529
2530 static void GLAPIENTRY
TAG(Color3iv)2531 TAG(Color3iv)(const GLint *v)
2532 {
2533 GET_CURRENT_CONTEXT(ctx);
2534 ATTR4F(VBO_ATTRIB_COLOR0, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
2535 INT_TO_FLOAT(v[2]), 1.0);
2536 }
2537
2538 static void GLAPIENTRY
TAG(Color3sv)2539 TAG(Color3sv)(const GLshort *v)
2540 {
2541 GET_CURRENT_CONTEXT(ctx);
2542 ATTR4F(VBO_ATTRIB_COLOR0, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
2543 SHORT_TO_FLOAT(v[2]), 1.0);
2544 }
2545
2546 static void GLAPIENTRY
TAG(Color3uiv)2547 TAG(Color3uiv)(const GLuint *v)
2548 {
2549 GET_CURRENT_CONTEXT(ctx);
2550 ATTR4F(VBO_ATTRIB_COLOR0, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
2551 UINT_TO_FLOAT(v[2]), 1.0);
2552 }
2553
2554 static void GLAPIENTRY
TAG(Color3usv)2555 TAG(Color3usv)(const GLushort *v)
2556 {
2557 GET_CURRENT_CONTEXT(ctx);
2558 ATTR4F(VBO_ATTRIB_COLOR0, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
2559 USHORT_TO_FLOAT(v[2]), 1.0);
2560 }
2561
2562 static void GLAPIENTRY
TAG(Color3ubv)2563 TAG(Color3ubv)(const GLubyte *v)
2564 {
2565 GET_CURRENT_CONTEXT(ctx);
2566 ATTR4F(VBO_ATTRIB_COLOR0, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]),
2567 UBYTE_TO_FLOAT(v[2]), 1.0);
2568 }
2569
2570
2571 static void GLAPIENTRY
TAG(Color4b)2572 TAG(Color4b)(GLbyte red, GLbyte green, GLbyte blue,
2573 GLbyte alpha)
2574 {
2575 GET_CURRENT_CONTEXT(ctx);
2576 ATTR4F(VBO_ATTRIB_COLOR0, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
2577 BYTE_TO_FLOAT(blue), BYTE_TO_FLOAT(alpha));
2578 }
2579
2580 static void GLAPIENTRY
TAG(Color4d)2581 TAG(Color4d)(GLdouble red, GLdouble green, GLdouble blue,
2582 GLdouble alpha)
2583 {
2584 GET_CURRENT_CONTEXT(ctx);
2585 ATTR4F(VBO_ATTRIB_COLOR0, (GLfloat) red, (GLfloat) green, (GLfloat) blue, (GLfloat) alpha);
2586 }
2587
2588 static void GLAPIENTRY
TAG(Color4i)2589 TAG(Color4i)(GLint red, GLint green, GLint blue, GLint alpha)
2590 {
2591 GET_CURRENT_CONTEXT(ctx);
2592 ATTR4F(VBO_ATTRIB_COLOR0, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
2593 INT_TO_FLOAT(blue), INT_TO_FLOAT(alpha));
2594 }
2595
2596 static void GLAPIENTRY
TAG(Color4s)2597 TAG(Color4s)(GLshort red, GLshort green, GLshort blue,
2598 GLshort alpha)
2599 {
2600 GET_CURRENT_CONTEXT(ctx);
2601 ATTR4F(VBO_ATTRIB_COLOR0, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
2602 SHORT_TO_FLOAT(blue), SHORT_TO_FLOAT(alpha));
2603 }
2604
2605 static void GLAPIENTRY
TAG(Color4ui)2606 TAG(Color4ui)(GLuint red, GLuint green, GLuint blue, GLuint alpha)
2607 {
2608 GET_CURRENT_CONTEXT(ctx);
2609 ATTR4F(VBO_ATTRIB_COLOR0, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
2610 UINT_TO_FLOAT(blue), UINT_TO_FLOAT(alpha));
2611 }
2612
2613 static void GLAPIENTRY
TAG(Color4us)2614 TAG(Color4us)(GLushort red, GLushort green, GLushort blue, GLushort alpha)
2615 {
2616 GET_CURRENT_CONTEXT(ctx);
2617 ATTR4F(VBO_ATTRIB_COLOR0, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
2618 USHORT_TO_FLOAT(blue), USHORT_TO_FLOAT(alpha));
2619 }
2620
2621 static void GLAPIENTRY
TAG(Color4ub)2622 TAG(Color4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
2623 {
2624 GET_CURRENT_CONTEXT(ctx);
2625 ATTR4F(VBO_ATTRIB_COLOR0, UBYTE_TO_FLOAT(red), UBYTE_TO_FLOAT(green),
2626 UBYTE_TO_FLOAT(blue), UBYTE_TO_FLOAT(alpha));
2627 }
2628
2629
2630 static void GLAPIENTRY
TAG(Color4iv)2631 TAG(Color4iv)(const GLint *v)
2632 {
2633 GET_CURRENT_CONTEXT(ctx);
2634 ATTR4F(VBO_ATTRIB_COLOR0, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
2635 INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]));
2636 }
2637
2638
2639 static void GLAPIENTRY
TAG(Color4bv)2640 TAG(Color4bv)(const GLbyte *v)
2641 {
2642 GET_CURRENT_CONTEXT(ctx);
2643 ATTR4F(VBO_ATTRIB_COLOR0, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
2644 BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]));
2645 }
2646
2647 static void GLAPIENTRY
TAG(Color4dv)2648 TAG(Color4dv)(const GLdouble *v)
2649 {
2650 GET_CURRENT_CONTEXT(ctx);
2651 ATTR4F(VBO_ATTRIB_COLOR0, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
2652 }
2653
2654
2655 static void GLAPIENTRY
TAG(Color4sv)2656 TAG(Color4sv)(const GLshort *v)
2657 {
2658 GET_CURRENT_CONTEXT(ctx);
2659 ATTR4F(VBO_ATTRIB_COLOR0, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
2660 SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]));
2661 }
2662
2663
2664 static void GLAPIENTRY
TAG(Color4uiv)2665 TAG(Color4uiv)(const GLuint *v)
2666 {
2667 GET_CURRENT_CONTEXT(ctx);
2668 ATTR4F(VBO_ATTRIB_COLOR0, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
2669 UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]));
2670 }
2671
2672 static void GLAPIENTRY
TAG(Color4usv)2673 TAG(Color4usv)(const GLushort *v)
2674 {
2675 GET_CURRENT_CONTEXT(ctx);
2676 ATTR4F(VBO_ATTRIB_COLOR0, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
2677 USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]));
2678 }
2679
2680 static void GLAPIENTRY
TAG(Color4ubv)2681 TAG(Color4ubv)(const GLubyte *v)
2682 {
2683 GET_CURRENT_CONTEXT(ctx);
2684 ATTR4F(VBO_ATTRIB_COLOR0, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]),
2685 UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3]));
2686 }
2687
2688
2689 static void GLAPIENTRY
TAG(FogCoordd)2690 TAG(FogCoordd)(GLdouble d)
2691 {
2692 GET_CURRENT_CONTEXT(ctx);
2693 ATTR1F(VBO_ATTRIB_FOG, (GLfloat) d);
2694 }
2695
2696 static void GLAPIENTRY
TAG(FogCoorddv)2697 TAG(FogCoorddv)(const GLdouble *v)
2698 {
2699 GET_CURRENT_CONTEXT(ctx);
2700 ATTR1F(VBO_ATTRIB_FOG, (GLfloat) *v);
2701 }
2702
2703
2704 static void GLAPIENTRY
TAG(Indexd)2705 TAG(Indexd)(GLdouble c)
2706 {
2707 GET_CURRENT_CONTEXT(ctx);
2708 ATTR1F(VBO_ATTRIB_COLOR_INDEX, (GLfloat) c);
2709 }
2710
2711 static void GLAPIENTRY
TAG(Indexi)2712 TAG(Indexi)(GLint c)
2713 {
2714 GET_CURRENT_CONTEXT(ctx);
2715 ATTR1F(VBO_ATTRIB_COLOR_INDEX, (GLfloat) c);
2716 }
2717
2718 static void GLAPIENTRY
TAG(Indexs)2719 TAG(Indexs)(GLshort c)
2720 {
2721 GET_CURRENT_CONTEXT(ctx);
2722 ATTR1F(VBO_ATTRIB_COLOR_INDEX, (GLfloat) c);
2723 }
2724
2725 static void GLAPIENTRY
TAG(Indexub)2726 TAG(Indexub)(GLubyte c)
2727 {
2728 GET_CURRENT_CONTEXT(ctx);
2729 ATTR1F(VBO_ATTRIB_COLOR_INDEX, (GLfloat) c);
2730 }
2731
2732 static void GLAPIENTRY
TAG(Indexdv)2733 TAG(Indexdv)(const GLdouble *c)
2734 {
2735 GET_CURRENT_CONTEXT(ctx);
2736 ATTR1F(VBO_ATTRIB_COLOR_INDEX, (GLfloat) *c);
2737 }
2738
2739 static void GLAPIENTRY
TAG(Indexiv)2740 TAG(Indexiv)(const GLint *c)
2741 {
2742 GET_CURRENT_CONTEXT(ctx);
2743 ATTR1F(VBO_ATTRIB_COLOR_INDEX, (GLfloat) *c);
2744 }
2745
2746 static void GLAPIENTRY
TAG(Indexsv)2747 TAG(Indexsv)(const GLshort *c)
2748 {
2749 GET_CURRENT_CONTEXT(ctx);
2750 ATTR1F(VBO_ATTRIB_COLOR_INDEX, (GLfloat) *c);
2751 }
2752
2753 static void GLAPIENTRY
TAG(Indexubv)2754 TAG(Indexubv)(const GLubyte *c)
2755 {
2756 GET_CURRENT_CONTEXT(ctx);
2757 ATTR1F(VBO_ATTRIB_COLOR_INDEX, (GLfloat) *c);
2758 }
2759
2760
2761 static void GLAPIENTRY
TAG(EdgeFlagv)2762 TAG(EdgeFlagv)(const GLboolean *flag)
2763 {
2764 GET_CURRENT_CONTEXT(ctx);
2765 ATTR1F(VBO_ATTRIB_EDGEFLAG, (GLfloat)*flag);
2766 }
2767
2768
2769 static void GLAPIENTRY
TAG(Normal3b)2770 TAG(Normal3b)(GLbyte nx, GLbyte ny, GLbyte nz)
2771 {
2772 GET_CURRENT_CONTEXT(ctx);
2773 ATTR3F(VBO_ATTRIB_NORMAL, BYTE_TO_FLOAT(nx), BYTE_TO_FLOAT(ny), BYTE_TO_FLOAT(nz));
2774 }
2775
2776 static void GLAPIENTRY
TAG(Normal3d)2777 TAG(Normal3d)(GLdouble nx, GLdouble ny, GLdouble nz)
2778 {
2779 GET_CURRENT_CONTEXT(ctx);
2780 ATTR3F(VBO_ATTRIB_NORMAL, (GLfloat) nx, (GLfloat) ny, (GLfloat) nz);
2781 }
2782
2783 static void GLAPIENTRY
TAG(Normal3i)2784 TAG(Normal3i)(GLint nx, GLint ny, GLint nz)
2785 {
2786 GET_CURRENT_CONTEXT(ctx);
2787 ATTR3F(VBO_ATTRIB_NORMAL, INT_TO_FLOAT(nx), INT_TO_FLOAT(ny), INT_TO_FLOAT(nz));
2788 }
2789
2790 static void GLAPIENTRY
TAG(Normal3s)2791 TAG(Normal3s)(GLshort nx, GLshort ny, GLshort nz)
2792 {
2793 GET_CURRENT_CONTEXT(ctx);
2794 ATTR3F(VBO_ATTRIB_NORMAL, SHORT_TO_FLOAT(nx), SHORT_TO_FLOAT(ny), SHORT_TO_FLOAT(nz));
2795 }
2796
2797 static void GLAPIENTRY
TAG(Normal3bv)2798 TAG(Normal3bv)(const GLbyte *v)
2799 {
2800 GET_CURRENT_CONTEXT(ctx);
2801 ATTR3F(VBO_ATTRIB_NORMAL, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]));
2802 }
2803
2804 static void GLAPIENTRY
TAG(Normal3dv)2805 TAG(Normal3dv)(const GLdouble *v)
2806 {
2807 GET_CURRENT_CONTEXT(ctx);
2808 ATTR3F(VBO_ATTRIB_NORMAL, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
2809 }
2810
2811 static void GLAPIENTRY
TAG(Normal3iv)2812 TAG(Normal3iv)(const GLint *v)
2813 {
2814 GET_CURRENT_CONTEXT(ctx);
2815 ATTR3F(VBO_ATTRIB_NORMAL, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]));
2816 }
2817
2818 static void GLAPIENTRY
TAG(Normal3sv)2819 TAG(Normal3sv)(const GLshort *v)
2820 {
2821 GET_CURRENT_CONTEXT(ctx);
2822 ATTR3F(VBO_ATTRIB_NORMAL, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]));
2823 }
2824
2825 static void GLAPIENTRY
TAG(TexCoord1d)2826 TAG(TexCoord1d)(GLdouble s)
2827 {
2828 GET_CURRENT_CONTEXT(ctx);
2829 ATTR1F(VBO_ATTRIB_TEX0, (GLfloat) s);
2830 }
2831
2832 static void GLAPIENTRY
TAG(TexCoord1i)2833 TAG(TexCoord1i)(GLint s)
2834 {
2835 GET_CURRENT_CONTEXT(ctx);
2836 ATTR1F(VBO_ATTRIB_TEX0, (GLfloat) s);
2837 }
2838
2839 static void GLAPIENTRY
TAG(TexCoord1s)2840 TAG(TexCoord1s)(GLshort s)
2841 {
2842 GET_CURRENT_CONTEXT(ctx);
2843 ATTR1F(VBO_ATTRIB_TEX0, (GLfloat) s);
2844 }
2845
2846 static void GLAPIENTRY
TAG(TexCoord2d)2847 TAG(TexCoord2d)(GLdouble s, GLdouble t)
2848 {
2849 GET_CURRENT_CONTEXT(ctx);
2850 ATTR2F(VBO_ATTRIB_TEX0, (GLfloat) s,(GLfloat) t);
2851 }
2852
2853 static void GLAPIENTRY
TAG(TexCoord2s)2854 TAG(TexCoord2s)(GLshort s, GLshort t)
2855 {
2856 GET_CURRENT_CONTEXT(ctx);
2857 ATTR2F(VBO_ATTRIB_TEX0, (GLfloat) s,(GLfloat) t);
2858 }
2859
2860 static void GLAPIENTRY
TAG(TexCoord2i)2861 TAG(TexCoord2i)(GLint s, GLint t)
2862 {
2863 GET_CURRENT_CONTEXT(ctx);
2864 ATTR2F(VBO_ATTRIB_TEX0, (GLfloat) s,(GLfloat) t);
2865 }
2866
2867 static void GLAPIENTRY
TAG(TexCoord3d)2868 TAG(TexCoord3d)(GLdouble s, GLdouble t, GLdouble r)
2869 {
2870 GET_CURRENT_CONTEXT(ctx);
2871 ATTR3F(VBO_ATTRIB_TEX0, (GLfloat) s,(GLfloat) t,(GLfloat) r);
2872 }
2873
2874 static void GLAPIENTRY
TAG(TexCoord3i)2875 TAG(TexCoord3i)(GLint s, GLint t, GLint r)
2876 {
2877 GET_CURRENT_CONTEXT(ctx);
2878 ATTR3F(VBO_ATTRIB_TEX0, (GLfloat) s,(GLfloat) t,(GLfloat) r);
2879 }
2880
2881 static void GLAPIENTRY
TAG(TexCoord3s)2882 TAG(TexCoord3s)(GLshort s, GLshort t, GLshort r)
2883 {
2884 GET_CURRENT_CONTEXT(ctx);
2885 ATTR3F(VBO_ATTRIB_TEX0, (GLfloat) s,(GLfloat) t,(GLfloat) r);
2886 }
2887
2888 static void GLAPIENTRY
TAG(TexCoord4d)2889 TAG(TexCoord4d)(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
2890 {
2891 GET_CURRENT_CONTEXT(ctx);
2892 ATTR4F(VBO_ATTRIB_TEX0, (GLfloat) s,(GLfloat) t,(GLfloat) r,(GLfloat) q);
2893 }
2894
2895 static void GLAPIENTRY
TAG(TexCoord4i)2896 TAG(TexCoord4i)(GLint s, GLint t, GLint r, GLint q)
2897 {
2898 GET_CURRENT_CONTEXT(ctx);
2899 ATTR4F(VBO_ATTRIB_TEX0, (GLfloat) s,(GLfloat) t,(GLfloat) r,(GLfloat) q);
2900 }
2901
2902 static void GLAPIENTRY
TAG(TexCoord4s)2903 TAG(TexCoord4s)(GLshort s, GLshort t, GLshort r, GLshort q)
2904 {
2905 GET_CURRENT_CONTEXT(ctx);
2906 ATTR4F(VBO_ATTRIB_TEX0, (GLfloat) s,(GLfloat) t,(GLfloat) r,(GLfloat) q);
2907 }
2908
2909 static void GLAPIENTRY
TAG(TexCoord1dv)2910 TAG(TexCoord1dv)(const GLdouble *v)
2911 {
2912 GET_CURRENT_CONTEXT(ctx);
2913 ATTR1F(VBO_ATTRIB_TEX0, (GLfloat) v[0]);
2914 }
2915
2916 static void GLAPIENTRY
TAG(TexCoord1iv)2917 TAG(TexCoord1iv)(const GLint *v)
2918 {
2919 GET_CURRENT_CONTEXT(ctx);
2920 ATTR1F(VBO_ATTRIB_TEX0, (GLfloat) v[0]);
2921 }
2922
2923 static void GLAPIENTRY
TAG(TexCoord1sv)2924 TAG(TexCoord1sv)(const GLshort *v)
2925 {
2926 GET_CURRENT_CONTEXT(ctx);
2927 ATTR1F(VBO_ATTRIB_TEX0, (GLfloat) v[0]);
2928 }
2929
2930 static void GLAPIENTRY
TAG(TexCoord2dv)2931 TAG(TexCoord2dv)(const GLdouble *v)
2932 {
2933 GET_CURRENT_CONTEXT(ctx);
2934 ATTR2F(VBO_ATTRIB_TEX0, (GLfloat) v[0],(GLfloat) v[1]);
2935 }
2936
2937 static void GLAPIENTRY
TAG(TexCoord2iv)2938 TAG(TexCoord2iv)(const GLint *v)
2939 {
2940 GET_CURRENT_CONTEXT(ctx);
2941 ATTR2F(VBO_ATTRIB_TEX0, (GLfloat) v[0],(GLfloat) v[1]);
2942 }
2943
2944 static void GLAPIENTRY
TAG(TexCoord2sv)2945 TAG(TexCoord2sv)(const GLshort *v)
2946 {
2947 GET_CURRENT_CONTEXT(ctx);
2948 ATTR2F(VBO_ATTRIB_TEX0, (GLfloat) v[0],(GLfloat) v[1]);
2949 }
2950
2951 static void GLAPIENTRY
TAG(TexCoord3dv)2952 TAG(TexCoord3dv)(const GLdouble *v)
2953 {
2954 GET_CURRENT_CONTEXT(ctx);
2955 ATTR3F(VBO_ATTRIB_TEX0, (GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2]);
2956 }
2957
2958 static void GLAPIENTRY
TAG(TexCoord3iv)2959 TAG(TexCoord3iv)(const GLint *v)
2960 {
2961 GET_CURRENT_CONTEXT(ctx);
2962 ATTR3F(VBO_ATTRIB_TEX0, (GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2]);
2963 }
2964
2965 static void GLAPIENTRY
TAG(TexCoord3sv)2966 TAG(TexCoord3sv)(const GLshort *v)
2967 {
2968 GET_CURRENT_CONTEXT(ctx);
2969 ATTR3F(VBO_ATTRIB_TEX0, (GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2]);
2970 }
2971
2972 static void GLAPIENTRY
TAG(TexCoord4dv)2973 TAG(TexCoord4dv)(const GLdouble *v)
2974 {
2975 GET_CURRENT_CONTEXT(ctx);
2976 ATTR4F(VBO_ATTRIB_TEX0, (GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2],(GLfloat) v[3]);
2977 }
2978
2979 static void GLAPIENTRY
TAG(TexCoord4iv)2980 TAG(TexCoord4iv)(const GLint *v)
2981 {
2982 GET_CURRENT_CONTEXT(ctx);
2983 ATTR4F(VBO_ATTRIB_TEX0, (GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2],(GLfloat) v[3]);
2984 }
2985
2986 static void GLAPIENTRY
TAG(TexCoord4sv)2987 TAG(TexCoord4sv)(const GLshort *v)
2988 {
2989 GET_CURRENT_CONTEXT(ctx);
2990 ATTR4F(VBO_ATTRIB_TEX0, (GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2],(GLfloat) v[3]);
2991 }
2992
2993 static void GLAPIENTRY
TAG(MultiTexCoord1d)2994 TAG(MultiTexCoord1d)(GLenum target, GLdouble s)
2995 {
2996 GET_CURRENT_CONTEXT(ctx);
2997 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
2998 ATTR1F(attr, (GLfloat) s);
2999 }
3000
3001 static void GLAPIENTRY
TAG(MultiTexCoord1dv)3002 TAG(MultiTexCoord1dv)(GLenum target, const GLdouble *v)
3003 {
3004 GET_CURRENT_CONTEXT(ctx);
3005 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3006 ATTR1F(attr, (GLfloat) v[0]);
3007 }
3008
3009 static void GLAPIENTRY
TAG(MultiTexCoord1i)3010 TAG(MultiTexCoord1i)(GLenum target, GLint s)
3011 {
3012 GET_CURRENT_CONTEXT(ctx);
3013 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3014 ATTR1F(attr, (GLfloat) s);
3015 }
3016
3017 static void GLAPIENTRY
TAG(MultiTexCoord1iv)3018 TAG(MultiTexCoord1iv)(GLenum target, const GLint *v)
3019 {
3020 GET_CURRENT_CONTEXT(ctx);
3021 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3022 ATTR1F(attr, (GLfloat) v[0]);
3023 }
3024
3025 static void GLAPIENTRY
TAG(MultiTexCoord1s)3026 TAG(MultiTexCoord1s)(GLenum target, GLshort s)
3027 {
3028 GET_CURRENT_CONTEXT(ctx);
3029 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3030 ATTR1F(attr, (GLfloat) s);
3031 }
3032
3033 static void GLAPIENTRY
TAG(MultiTexCoord1sv)3034 TAG(MultiTexCoord1sv)(GLenum target, const GLshort *v)
3035 {
3036 GET_CURRENT_CONTEXT(ctx);
3037 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3038 ATTR1F(attr, (GLfloat) v[0]);
3039 }
3040
3041 static void GLAPIENTRY
TAG(MultiTexCoord2d)3042 TAG(MultiTexCoord2d)(GLenum target, GLdouble s, GLdouble t)
3043 {
3044 GET_CURRENT_CONTEXT(ctx);
3045 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3046 ATTR2F(attr, (GLfloat) s, (GLfloat) t);
3047 }
3048
3049 static void GLAPIENTRY
TAG(MultiTexCoord2dv)3050 TAG(MultiTexCoord2dv)(GLenum target, const GLdouble *v)
3051 {
3052 GET_CURRENT_CONTEXT(ctx);
3053 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3054 ATTR2F(attr, (GLfloat) v[0], (GLfloat) v[1]);
3055 }
3056
3057 static void GLAPIENTRY
TAG(MultiTexCoord2i)3058 TAG(MultiTexCoord2i)(GLenum target, GLint s, GLint t)
3059 {
3060 GET_CURRENT_CONTEXT(ctx);
3061 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3062 ATTR2F(attr, (GLfloat) s, (GLfloat) t);
3063 }
3064
3065 static void GLAPIENTRY
TAG(MultiTexCoord2iv)3066 TAG(MultiTexCoord2iv)(GLenum target, const GLint *v)
3067 {
3068 GET_CURRENT_CONTEXT(ctx);
3069 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3070 ATTR2F(attr, (GLfloat) v[0], (GLfloat) v[1]);
3071 }
3072
3073 static void GLAPIENTRY
TAG(MultiTexCoord2s)3074 TAG(MultiTexCoord2s)(GLenum target, GLshort s, GLshort t)
3075 {
3076 GET_CURRENT_CONTEXT(ctx);
3077 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3078 ATTR2F(attr, (GLfloat) s, (GLfloat) t);
3079 }
3080
3081 static void GLAPIENTRY
TAG(MultiTexCoord2sv)3082 TAG(MultiTexCoord2sv)(GLenum target, const GLshort *v)
3083 {
3084 GET_CURRENT_CONTEXT(ctx);
3085 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3086 ATTR2F(attr, (GLfloat) v[0], (GLfloat) v[1]);
3087 }
3088
3089 static void GLAPIENTRY
TAG(MultiTexCoord3d)3090 TAG(MultiTexCoord3d)(GLenum target, GLdouble s, GLdouble t, GLdouble r)
3091 {
3092 GET_CURRENT_CONTEXT(ctx);
3093 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3094 ATTR3F(attr, (GLfloat) s, (GLfloat) t, (GLfloat) r);
3095 }
3096
3097 static void GLAPIENTRY
TAG(MultiTexCoord3dv)3098 TAG(MultiTexCoord3dv)(GLenum target, const GLdouble *v)
3099 {
3100 GET_CURRENT_CONTEXT(ctx);
3101 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3102 ATTR3F(attr, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
3103 }
3104
3105 static void GLAPIENTRY
TAG(MultiTexCoord3i)3106 TAG(MultiTexCoord3i)(GLenum target, GLint s, GLint t, GLint r)
3107 {
3108 GET_CURRENT_CONTEXT(ctx);
3109 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3110 ATTR3F(attr, (GLfloat) s, (GLfloat) t, (GLfloat) r);
3111 }
3112
3113 static void GLAPIENTRY
TAG(MultiTexCoord3iv)3114 TAG(MultiTexCoord3iv)(GLenum target, const GLint *v)
3115 {
3116 GET_CURRENT_CONTEXT(ctx);
3117 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3118 ATTR3F(attr, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
3119 }
3120
3121 static void GLAPIENTRY
TAG(MultiTexCoord3s)3122 TAG(MultiTexCoord3s)(GLenum target, GLshort s, GLshort t, GLshort r)
3123 {
3124 GET_CURRENT_CONTEXT(ctx);
3125 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3126 ATTR3F(attr, (GLfloat) s, (GLfloat) t, (GLfloat) r);
3127 }
3128
3129 static void GLAPIENTRY
TAG(MultiTexCoord3sv)3130 TAG(MultiTexCoord3sv)(GLenum target, const GLshort *v)
3131 {
3132 GET_CURRENT_CONTEXT(ctx);
3133 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3134 ATTR3F(attr, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
3135 }
3136
3137 static void GLAPIENTRY
TAG(MultiTexCoord4d)3138 TAG(MultiTexCoord4d)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
3139 {
3140 GET_CURRENT_CONTEXT(ctx);
3141 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3142 ATTR4F(attr, (GLfloat) s, (GLfloat) t, (GLfloat) r, (GLfloat) q);
3143 }
3144
3145 static void GLAPIENTRY
TAG(MultiTexCoord4dv)3146 TAG(MultiTexCoord4dv)(GLenum target, const GLdouble *v)
3147 {
3148 GET_CURRENT_CONTEXT(ctx);
3149 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3150 ATTR4F(attr, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
3151 }
3152
3153 static void GLAPIENTRY
TAG(MultiTexCoord4i)3154 TAG(MultiTexCoord4i)(GLenum target, GLint s, GLint t, GLint r, GLint q)
3155 {
3156 GET_CURRENT_CONTEXT(ctx);
3157 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3158 ATTR4F(attr, (GLfloat) s, (GLfloat) t, (GLfloat) r, (GLfloat) q);
3159 }
3160
3161 static void GLAPIENTRY
TAG(MultiTexCoord4iv)3162 TAG(MultiTexCoord4iv)(GLenum target, const GLint *v)
3163 {
3164 GET_CURRENT_CONTEXT(ctx);
3165 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3166 ATTR4F(attr, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
3167 }
3168
3169 static void GLAPIENTRY
TAG(MultiTexCoord4s)3170 TAG(MultiTexCoord4s)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
3171 {
3172 GET_CURRENT_CONTEXT(ctx);
3173 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3174 ATTR4F(attr, (GLfloat) s, (GLfloat) t, (GLfloat) r, (GLfloat) q);
3175 }
3176
3177 static void GLAPIENTRY
TAG(MultiTexCoord4sv)3178 TAG(MultiTexCoord4sv)(GLenum target, const GLshort *v)
3179 {
3180 GET_CURRENT_CONTEXT(ctx);
3181 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
3182 ATTR4F(attr, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
3183 }
3184
3185
3186 static void GLAPIENTRY
TAG(EvalCoord2dv)3187 TAG(EvalCoord2dv)(const GLdouble *u)
3188 {
3189 TAG(EvalCoord2f)((GLfloat) u[0], (GLfloat) u[1]);
3190 }
3191
3192 static void GLAPIENTRY
TAG(EvalCoord2d)3193 TAG(EvalCoord2d)(GLdouble u, GLdouble v)
3194 {
3195 TAG(EvalCoord2f)((GLfloat) u, (GLfloat) v);
3196 }
3197
3198 static void GLAPIENTRY
TAG(EvalCoord1dv)3199 TAG(EvalCoord1dv)(const GLdouble *u)
3200 {
3201 TAG(EvalCoord1f)((GLfloat) *u);
3202 }
3203
3204 static void GLAPIENTRY
TAG(EvalCoord1d)3205 TAG(EvalCoord1d)(GLdouble u)
3206 {
3207 TAG(EvalCoord1f)((GLfloat) u);
3208 }
3209
3210
3211 static void GLAPIENTRY
TAG(Materialf)3212 TAG(Materialf)(GLenum face, GLenum pname, GLfloat param)
3213 {
3214 GLfloat fparam[4];
3215 fparam[0] = param;
3216 TAG(Materialfv)(face, pname, fparam);
3217 }
3218
3219 static void GLAPIENTRY
TAG(Materiali)3220 TAG(Materiali)(GLenum face, GLenum pname, GLint param)
3221 {
3222 GLfloat p[4];
3223 p[0] = (GLfloat) param;
3224 TAG(Materialfv)(face, pname, p);
3225 }
3226
3227 static void GLAPIENTRY
TAG(Materialiv)3228 TAG(Materialiv)(GLenum face, GLenum pname, const GLint *params)
3229 {
3230 GLfloat fparam[4];
3231 switch (pname) {
3232 case GL_AMBIENT:
3233 case GL_DIFFUSE:
3234 case GL_SPECULAR:
3235 case GL_EMISSION:
3236 case GL_AMBIENT_AND_DIFFUSE:
3237 fparam[0] = INT_TO_FLOAT(params[0]);
3238 fparam[1] = INT_TO_FLOAT(params[1]);
3239 fparam[2] = INT_TO_FLOAT(params[2]);
3240 fparam[3] = INT_TO_FLOAT(params[3]);
3241 break;
3242 case GL_SHININESS:
3243 fparam[0] = (GLfloat) params[0];
3244 break;
3245 case GL_COLOR_INDEXES:
3246 fparam[0] = (GLfloat) params[0];
3247 fparam[1] = (GLfloat) params[1];
3248 fparam[2] = (GLfloat) params[2];
3249 break;
3250 default:
3251 ;
3252 }
3253 TAG(Materialfv)(face, pname, fparam);
3254 }
3255
3256
3257 static void GLAPIENTRY
TAG(SecondaryColor3b)3258 TAG(SecondaryColor3b)(GLbyte red, GLbyte green, GLbyte blue)
3259 {
3260 GET_CURRENT_CONTEXT(ctx);
3261 ATTR3F(VBO_ATTRIB_COLOR1, BYTE_TO_FLOAT(red),
3262 BYTE_TO_FLOAT(green),
3263 BYTE_TO_FLOAT(blue));
3264 }
3265
3266 static void GLAPIENTRY
TAG(SecondaryColor3d)3267 TAG(SecondaryColor3d)(GLdouble red, GLdouble green, GLdouble blue)
3268 {
3269 GET_CURRENT_CONTEXT(ctx);
3270 ATTR3F(VBO_ATTRIB_COLOR1, (GLfloat) red, (GLfloat) green, (GLfloat) blue);
3271 }
3272
3273 static void GLAPIENTRY
TAG(SecondaryColor3i)3274 TAG(SecondaryColor3i)(GLint red, GLint green, GLint blue)
3275 {
3276 GET_CURRENT_CONTEXT(ctx);
3277 ATTR3F(VBO_ATTRIB_COLOR1, INT_TO_FLOAT(red),
3278 INT_TO_FLOAT(green),
3279 INT_TO_FLOAT(blue));
3280 }
3281
3282 static void GLAPIENTRY
TAG(SecondaryColor3s)3283 TAG(SecondaryColor3s)(GLshort red, GLshort green, GLshort blue)
3284 {
3285 GET_CURRENT_CONTEXT(ctx);
3286 ATTR3F(VBO_ATTRIB_COLOR1, SHORT_TO_FLOAT(red),
3287 SHORT_TO_FLOAT(green),
3288 SHORT_TO_FLOAT(blue));
3289 }
3290
3291 static void GLAPIENTRY
TAG(SecondaryColor3ui)3292 TAG(SecondaryColor3ui)(GLuint red, GLuint green, GLuint blue)
3293 {
3294 GET_CURRENT_CONTEXT(ctx);
3295 ATTR3F(VBO_ATTRIB_COLOR1, UINT_TO_FLOAT(red),
3296 UINT_TO_FLOAT(green),
3297 UINT_TO_FLOAT(blue));
3298 }
3299
3300 static void GLAPIENTRY
TAG(SecondaryColor3us)3301 TAG(SecondaryColor3us)(GLushort red, GLushort green, GLushort blue)
3302 {
3303 GET_CURRENT_CONTEXT(ctx);
3304 ATTR3F(VBO_ATTRIB_COLOR1, USHORT_TO_FLOAT(red),
3305 USHORT_TO_FLOAT(green),
3306 USHORT_TO_FLOAT(blue));
3307 }
3308
3309 static void GLAPIENTRY
TAG(SecondaryColor3ub)3310 TAG(SecondaryColor3ub)(GLubyte red, GLubyte green, GLubyte blue)
3311 {
3312 GET_CURRENT_CONTEXT(ctx);
3313 ATTR3F(VBO_ATTRIB_COLOR1, UBYTE_TO_FLOAT(red),
3314 UBYTE_TO_FLOAT(green),
3315 UBYTE_TO_FLOAT(blue));
3316 }
3317
3318 static void GLAPIENTRY
TAG(SecondaryColor3bv)3319 TAG(SecondaryColor3bv)(const GLbyte *v)
3320 {
3321 GET_CURRENT_CONTEXT(ctx);
3322 ATTR3F(VBO_ATTRIB_COLOR1, BYTE_TO_FLOAT(v[0]),
3323 BYTE_TO_FLOAT(v[1]),
3324 BYTE_TO_FLOAT(v[2]));
3325 }
3326
3327 static void GLAPIENTRY
TAG(SecondaryColor3dv)3328 TAG(SecondaryColor3dv)(const GLdouble *v)
3329 {
3330 GET_CURRENT_CONTEXT(ctx);
3331 ATTR3F(VBO_ATTRIB_COLOR1, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
3332 }
3333
3334 static void GLAPIENTRY
TAG(SecondaryColor3iv)3335 TAG(SecondaryColor3iv)(const GLint *v)
3336 {
3337 GET_CURRENT_CONTEXT(ctx);
3338 ATTR3F(VBO_ATTRIB_COLOR1, INT_TO_FLOAT(v[0]),
3339 INT_TO_FLOAT(v[1]),
3340 INT_TO_FLOAT(v[2]));
3341 }
3342
3343 static void GLAPIENTRY
TAG(SecondaryColor3sv)3344 TAG(SecondaryColor3sv)(const GLshort *v)
3345 {
3346 GET_CURRENT_CONTEXT(ctx);
3347 ATTR3F(VBO_ATTRIB_COLOR1, SHORT_TO_FLOAT(v[0]),
3348 SHORT_TO_FLOAT(v[1]),
3349 SHORT_TO_FLOAT(v[2]));
3350 }
3351
3352 static void GLAPIENTRY
TAG(SecondaryColor3uiv)3353 TAG(SecondaryColor3uiv)(const GLuint *v)
3354 {
3355 GET_CURRENT_CONTEXT(ctx);
3356 ATTR3F(VBO_ATTRIB_COLOR1, UINT_TO_FLOAT(v[0]),
3357 UINT_TO_FLOAT(v[1]),
3358 UINT_TO_FLOAT(v[2]));
3359 }
3360
3361 static void GLAPIENTRY
TAG(SecondaryColor3usv)3362 TAG(SecondaryColor3usv)(const GLushort *v)
3363 {
3364 GET_CURRENT_CONTEXT(ctx);
3365 ATTR3F(VBO_ATTRIB_COLOR1, USHORT_TO_FLOAT(v[0]),
3366 USHORT_TO_FLOAT(v[1]),
3367 USHORT_TO_FLOAT(v[2]));
3368 }
3369
3370 static void GLAPIENTRY
TAG(SecondaryColor3ubv)3371 TAG(SecondaryColor3ubv)(const GLubyte *v)
3372 {
3373 GET_CURRENT_CONTEXT(ctx);
3374 ATTR3F(VBO_ATTRIB_COLOR1, UBYTE_TO_FLOAT(v[0]),
3375 UBYTE_TO_FLOAT(v[1]),
3376 UBYTE_TO_FLOAT(v[2]));
3377 }
3378
3379 #endif /* HW_SELECT_MODE */
3380
3381 #undef ATTR1FV
3382 #undef ATTR2FV
3383 #undef ATTR3FV
3384 #undef ATTR4FV
3385
3386 #undef ATTR1F
3387 #undef ATTR2F
3388 #undef ATTR3F
3389 #undef ATTR4F
3390
3391 #undef ATTR_UI
3392
3393 #ifdef SUPPRESS_STATIC
3394 #undef static
3395 #endif
3396
3397 #undef MAT
3398