1 /**************************************************************************
2
3 Copyright 2002 Tungsten Graphics Inc., Cedar Park, Texas.
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 TUNGSTEN GRAPHICS 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 /* float */
29 #define ATTR1FV( A, V ) ATTR( A, 1, GL_FLOAT, (V)[0], 0, 0, 1 )
30 #define ATTR2FV( A, V ) ATTR( A, 2, GL_FLOAT, (V)[0], (V)[1], 0, 1 )
31 #define ATTR3FV( A, V ) ATTR( A, 3, GL_FLOAT, (V)[0], (V)[1], (V)[2], 1 )
32 #define ATTR4FV( A, V ) ATTR( A, 4, GL_FLOAT, (V)[0], (V)[1], (V)[2], (V)[3] )
33
34 #define ATTR1F( A, X ) ATTR( A, 1, GL_FLOAT, X, 0, 0, 1 )
35 #define ATTR2F( A, X, Y ) ATTR( A, 2, GL_FLOAT, X, Y, 0, 1 )
36 #define ATTR3F( A, X, Y, Z ) ATTR( A, 3, GL_FLOAT, X, Y, Z, 1 )
37 #define ATTR4F( A, X, Y, Z, W ) ATTR( A, 4, GL_FLOAT, X, Y, Z, W )
38
39 /* int */
40 #define ATTRI( A, N, X, Y, Z, W) ATTR( A, N, GL_INT, \
41 INT_AS_FLT(X), INT_AS_FLT(Y), \
42 INT_AS_FLT(Z), INT_AS_FLT(W) )
43
44 #define ATTR2IV( A, V ) ATTRI( A, 2, (V)[0], (V)[1], 0, 1 )
45 #define ATTR3IV( A, V ) ATTRI( A, 3, (V)[0], (V)[1], (V)[2], 1 )
46 #define ATTR4IV( A, V ) ATTRI( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
47
48 #define ATTR1I( A, X ) ATTRI( A, 1, X, 0, 0, 1 )
49 #define ATTR2I( A, X, Y ) ATTRI( A, 2, X, Y, 0, 1 )
50 #define ATTR3I( A, X, Y, Z ) ATTRI( A, 3, X, Y, Z, 1 )
51 #define ATTR4I( A, X, Y, Z, W ) ATTRI( A, 4, X, Y, Z, W )
52
53
54 /* uint */
55 #define ATTRUI( A, N, X, Y, Z, W) ATTR( A, N, GL_UNSIGNED_INT, \
56 UINT_AS_FLT(X), UINT_AS_FLT(Y), \
57 UINT_AS_FLT(Z), UINT_AS_FLT(W) )
58
59 #define ATTR2UIV( A, V ) ATTRUI( A, 2, (V)[0], (V)[1], 0, 1 )
60 #define ATTR3UIV( A, V ) ATTRUI( A, 3, (V)[0], (V)[1], (V)[2], 1 )
61 #define ATTR4UIV( A, V ) ATTRUI( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
62
63 #define ATTR1UI( A, X ) ATTRUI( A, 1, X, 0, 0, 1 )
64 #define ATTR2UI( A, X, Y ) ATTRUI( A, 2, X, Y, 0, 1 )
65 #define ATTR3UI( A, X, Y, Z ) ATTRUI( A, 3, X, Y, Z, 1 )
66 #define ATTR4UI( A, X, Y, Z, W ) ATTRUI( A, 4, X, Y, Z, W )
67
68 #define MAT_ATTR( A, N, V ) ATTR( A, N, GL_FLOAT, (V)[0], (V)[1], (V)[2], (V)[3] )
69
conv_ui10_to_norm_float(unsigned ui10)70 static inline float conv_ui10_to_norm_float(unsigned ui10)
71 {
72 return (float)(ui10) / 1023.0;
73 }
74
conv_ui2_to_norm_float(unsigned ui2)75 static inline float conv_ui2_to_norm_float(unsigned ui2)
76 {
77 return (float)(ui2) / 3.0;
78 }
79
80 #define ATTRUI10_1( A, UI ) ATTR( A, 1, GL_FLOAT, (UI) & 0x3ff, 0, 0, 1 )
81 #define ATTRUI10_2( A, UI ) ATTR( A, 2, GL_FLOAT, (UI) & 0x3ff, ((UI) >> 10) & 0x3ff, 0, 1 )
82 #define ATTRUI10_3( A, UI ) ATTR( A, 3, GL_FLOAT, (UI) & 0x3ff, ((UI) >> 10) & 0x3ff, ((UI) >> 20) & 0x3ff, 1 )
83 #define ATTRUI10_4( A, UI ) ATTR( A, 4, GL_FLOAT, (UI) & 0x3ff, ((UI) >> 10) & 0x3ff, ((UI) >> 20) & 0x3ff, ((UI) >> 30) & 0x3 )
84
85 #define ATTRUI10N_1( A, UI ) ATTR( A, 1, GL_FLOAT, conv_ui10_to_norm_float((UI) & 0x3ff), 0, 0, 1 )
86 #define ATTRUI10N_2( A, UI ) ATTR( A, 2, GL_FLOAT, \
87 conv_ui10_to_norm_float((UI) & 0x3ff), \
88 conv_ui10_to_norm_float(((UI) >> 10) & 0x3ff), 0, 1 )
89 #define ATTRUI10N_3( A, UI ) ATTR( A, 3, GL_FLOAT, \
90 conv_ui10_to_norm_float((UI) & 0x3ff), \
91 conv_ui10_to_norm_float(((UI) >> 10) & 0x3ff), \
92 conv_ui10_to_norm_float(((UI) >> 20) & 0x3ff), 1 )
93 #define ATTRUI10N_4( A, UI ) ATTR( A, 4, GL_FLOAT, \
94 conv_ui10_to_norm_float((UI) & 0x3ff), \
95 conv_ui10_to_norm_float(((UI) >> 10) & 0x3ff), \
96 conv_ui10_to_norm_float(((UI) >> 20) & 0x3ff), \
97 conv_ui2_to_norm_float(((UI) >> 30) & 0x3) )
98
99 struct attr_bits_10 {signed int x:10;};
100 struct attr_bits_2 {signed int x:2;};
101
conv_i10_to_i(int i10)102 static inline float conv_i10_to_i(int i10)
103 {
104 struct attr_bits_10 val;
105 val.x = i10;
106 return (float)val.x;
107 }
108
conv_i2_to_i(int i2)109 static inline float conv_i2_to_i(int i2)
110 {
111 struct attr_bits_2 val;
112 val.x = i2;
113 return (float)val.x;
114 }
115
conv_i10_to_norm_float(int i10)116 static inline float conv_i10_to_norm_float(int i10)
117 {
118 struct attr_bits_10 val;
119 val.x = i10;
120 return (2.0F * (float)val.x + 1.0F) * (1.0F / 511.0F);
121 }
122
conv_i2_to_norm_float(int i2)123 static inline float conv_i2_to_norm_float(int i2)
124 {
125 struct attr_bits_2 val;
126 val.x = i2;
127 return (float)val.x;
128 }
129
130 #define ATTRI10_1( A, I10 ) ATTR( A, 1, GL_FLOAT, conv_i10_to_i((I10) & 0x3ff), 0, 0, 1 )
131 #define ATTRI10_2( A, I10 ) ATTR( A, 2, GL_FLOAT, \
132 conv_i10_to_i((I10) & 0x3ff), \
133 conv_i10_to_i(((I10) >> 10) & 0x3ff), 0, 1 )
134 #define ATTRI10_3( A, I10 ) ATTR( A, 3, GL_FLOAT, \
135 conv_i10_to_i((I10) & 0x3ff), \
136 conv_i10_to_i(((I10) >> 10) & 0x3ff), \
137 conv_i10_to_i(((I10) >> 20) & 0x3ff), 1 )
138 #define ATTRI10_4( A, I10 ) ATTR( A, 4, GL_FLOAT, \
139 conv_i10_to_i((I10) & 0x3ff), \
140 conv_i10_to_i(((I10) >> 10) & 0x3ff), \
141 conv_i10_to_i(((I10) >> 20) & 0x3ff), \
142 conv_i2_to_i(((I10) >> 30) & 0x3))
143
144
145 #define ATTRI10N_1( A, I10 ) ATTR( A, 1, GL_FLOAT, conv_i10_to_norm_float((I10) & 0x3ff), 0, 0, 1 )
146 #define ATTRI10N_2( A, I10 ) ATTR( A, 2, GL_FLOAT, \
147 conv_i10_to_norm_float((I10) & 0x3ff), \
148 conv_i10_to_norm_float(((I10) >> 10) & 0x3ff), 0, 1 )
149 #define ATTRI10N_3( A, I10 ) ATTR( A, 3, GL_FLOAT, \
150 conv_i10_to_norm_float((I10) & 0x3ff), \
151 conv_i10_to_norm_float(((I10) >> 10) & 0x3ff), \
152 conv_i10_to_norm_float(((I10) >> 20) & 0x3ff), 1 )
153 #define ATTRI10N_4( A, I10 ) ATTR( A, 4, GL_FLOAT, \
154 conv_i10_to_norm_float((I10) & 0x3ff), \
155 conv_i10_to_norm_float(((I10) >> 10) & 0x3ff), \
156 conv_i10_to_norm_float(((I10) >> 20) & 0x3ff), \
157 conv_i2_to_norm_float(((I10) >> 30) & 0x3))
158
159 #define ATTR_UI(val, type, normalized, attr, arg) do { \
160 if ((type) == GL_UNSIGNED_INT_2_10_10_10_REV) { \
161 if (normalized) { \
162 ATTRUI10N_##val((attr), (arg)); \
163 } else { \
164 ATTRUI10_##val((attr), (arg)); \
165 } \
166 } else if ((type) == GL_INT_2_10_10_10_REV) { \
167 if (normalized) { \
168 ATTRI10N_##val((attr), (arg)); \
169 } else { \
170 ATTRI10_##val((attr), (arg)); \
171 } \
172 } else \
173 ERROR(GL_INVALID_VALUE); \
174 } while(0)
175
176 #define ATTR_UI_INDEX(val, type, normalized, index, arg) do { \
177 if ((index) == 0) { \
178 ATTR_UI(val, (type), normalized, 0, (arg)); \
179 } else if ((index) < MAX_VERTEX_GENERIC_ATTRIBS) { \
180 ATTR_UI(val, (type), normalized, VBO_ATTRIB_GENERIC0 + (index), (arg)); \
181 } else \
182 ERROR(GL_INVALID_VALUE); \
183 } while(0)
184
185 static void GLAPIENTRY
TAG(Vertex2f)186 TAG(Vertex2f)(GLfloat x, GLfloat y)
187 {
188 GET_CURRENT_CONTEXT(ctx);
189 ATTR2F(VBO_ATTRIB_POS, x, y);
190 }
191
192 static void GLAPIENTRY
TAG(Vertex2fv)193 TAG(Vertex2fv)(const GLfloat * v)
194 {
195 GET_CURRENT_CONTEXT(ctx);
196 ATTR2FV(VBO_ATTRIB_POS, v);
197 }
198
199 static void GLAPIENTRY
TAG(Vertex3f)200 TAG(Vertex3f)(GLfloat x, GLfloat y, GLfloat z)
201 {
202 GET_CURRENT_CONTEXT(ctx);
203 ATTR3F(VBO_ATTRIB_POS, x, y, z);
204 }
205
206 static void GLAPIENTRY
TAG(Vertex3fv)207 TAG(Vertex3fv)(const GLfloat * v)
208 {
209 GET_CURRENT_CONTEXT(ctx);
210 ATTR3FV(VBO_ATTRIB_POS, v);
211 }
212
213 static void GLAPIENTRY
TAG(Vertex4f)214 TAG(Vertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
215 {
216 GET_CURRENT_CONTEXT(ctx);
217 ATTR4F(VBO_ATTRIB_POS, x, y, z, w);
218 }
219
220 static void GLAPIENTRY
TAG(Vertex4fv)221 TAG(Vertex4fv)(const GLfloat * v)
222 {
223 GET_CURRENT_CONTEXT(ctx);
224 ATTR4FV(VBO_ATTRIB_POS, v);
225 }
226
227
228
229 static void GLAPIENTRY
TAG(TexCoord1f)230 TAG(TexCoord1f)(GLfloat x)
231 {
232 GET_CURRENT_CONTEXT(ctx);
233 ATTR1F(VBO_ATTRIB_TEX0, x);
234 }
235
236 static void GLAPIENTRY
TAG(TexCoord1fv)237 TAG(TexCoord1fv)(const GLfloat * v)
238 {
239 GET_CURRENT_CONTEXT(ctx);
240 ATTR1FV(VBO_ATTRIB_TEX0, v);
241 }
242
243 static void GLAPIENTRY
TAG(TexCoord2f)244 TAG(TexCoord2f)(GLfloat x, GLfloat y)
245 {
246 GET_CURRENT_CONTEXT(ctx);
247 ATTR2F(VBO_ATTRIB_TEX0, x, y);
248 }
249
250 static void GLAPIENTRY
TAG(TexCoord2fv)251 TAG(TexCoord2fv)(const GLfloat * v)
252 {
253 GET_CURRENT_CONTEXT(ctx);
254 ATTR2FV(VBO_ATTRIB_TEX0, v);
255 }
256
257 static void GLAPIENTRY
TAG(TexCoord3f)258 TAG(TexCoord3f)(GLfloat x, GLfloat y, GLfloat z)
259 {
260 GET_CURRENT_CONTEXT(ctx);
261 ATTR3F(VBO_ATTRIB_TEX0, x, y, z);
262 }
263
264 static void GLAPIENTRY
TAG(TexCoord3fv)265 TAG(TexCoord3fv)(const GLfloat * v)
266 {
267 GET_CURRENT_CONTEXT(ctx);
268 ATTR3FV(VBO_ATTRIB_TEX0, v);
269 }
270
271 static void GLAPIENTRY
TAG(TexCoord4f)272 TAG(TexCoord4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
273 {
274 GET_CURRENT_CONTEXT(ctx);
275 ATTR4F(VBO_ATTRIB_TEX0, x, y, z, w);
276 }
277
278 static void GLAPIENTRY
TAG(TexCoord4fv)279 TAG(TexCoord4fv)(const GLfloat * v)
280 {
281 GET_CURRENT_CONTEXT(ctx);
282 ATTR4FV(VBO_ATTRIB_TEX0, v);
283 }
284
285
286
287 static void GLAPIENTRY
TAG(Normal3f)288 TAG(Normal3f)(GLfloat x, GLfloat y, GLfloat z)
289 {
290 GET_CURRENT_CONTEXT(ctx);
291 ATTR3F(VBO_ATTRIB_NORMAL, x, y, z);
292 }
293
294 static void GLAPIENTRY
TAG(Normal3fv)295 TAG(Normal3fv)(const GLfloat * v)
296 {
297 GET_CURRENT_CONTEXT(ctx);
298 ATTR3FV(VBO_ATTRIB_NORMAL, v);
299 }
300
301
302
303 static void GLAPIENTRY
TAG(FogCoordfEXT)304 TAG(FogCoordfEXT)(GLfloat x)
305 {
306 GET_CURRENT_CONTEXT(ctx);
307 ATTR1F(VBO_ATTRIB_FOG, x);
308 }
309
310
311
312 static void GLAPIENTRY
TAG(FogCoordfvEXT)313 TAG(FogCoordfvEXT)(const GLfloat * v)
314 {
315 GET_CURRENT_CONTEXT(ctx);
316 ATTR1FV(VBO_ATTRIB_FOG, v);
317 }
318
319 static void GLAPIENTRY
TAG(Color3f)320 TAG(Color3f)(GLfloat x, GLfloat y, GLfloat z)
321 {
322 GET_CURRENT_CONTEXT(ctx);
323 ATTR3F(VBO_ATTRIB_COLOR0, x, y, z);
324 }
325
326 static void GLAPIENTRY
TAG(Color3fv)327 TAG(Color3fv)(const GLfloat * v)
328 {
329 GET_CURRENT_CONTEXT(ctx);
330 ATTR3FV(VBO_ATTRIB_COLOR0, v);
331 }
332
333 static void GLAPIENTRY
TAG(Color4f)334 TAG(Color4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
335 {
336 GET_CURRENT_CONTEXT(ctx);
337 ATTR4F(VBO_ATTRIB_COLOR0, x, y, z, w);
338 }
339
340 static void GLAPIENTRY
TAG(Color4fv)341 TAG(Color4fv)(const GLfloat * v)
342 {
343 GET_CURRENT_CONTEXT(ctx);
344 ATTR4FV(VBO_ATTRIB_COLOR0, v);
345 }
346
347
348
349 static void GLAPIENTRY
TAG(SecondaryColor3fEXT)350 TAG(SecondaryColor3fEXT)(GLfloat x, GLfloat y, GLfloat z)
351 {
352 GET_CURRENT_CONTEXT(ctx);
353 ATTR3F(VBO_ATTRIB_COLOR1, x, y, z);
354 }
355
356 static void GLAPIENTRY
TAG(SecondaryColor3fvEXT)357 TAG(SecondaryColor3fvEXT)(const GLfloat * v)
358 {
359 GET_CURRENT_CONTEXT(ctx);
360 ATTR3FV(VBO_ATTRIB_COLOR1, v);
361 }
362
363
364
365 static void GLAPIENTRY
TAG(EdgeFlag)366 TAG(EdgeFlag)(GLboolean b)
367 {
368 GET_CURRENT_CONTEXT(ctx);
369 ATTR1F(VBO_ATTRIB_EDGEFLAG, (GLfloat) b);
370 }
371
372
373
374 static void GLAPIENTRY
TAG(Indexf)375 TAG(Indexf)(GLfloat f)
376 {
377 GET_CURRENT_CONTEXT(ctx);
378 ATTR1F(VBO_ATTRIB_INDEX, f);
379 }
380
381 static void GLAPIENTRY
TAG(Indexfv)382 TAG(Indexfv)(const GLfloat * f)
383 {
384 GET_CURRENT_CONTEXT(ctx);
385 ATTR1FV(VBO_ATTRIB_INDEX, f);
386 }
387
388
389
390 static void GLAPIENTRY
TAG(MultiTexCoord1f)391 TAG(MultiTexCoord1f)(GLenum target, GLfloat x)
392 {
393 GET_CURRENT_CONTEXT(ctx);
394 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
395 ATTR1F(attr, x);
396 }
397
398 static void GLAPIENTRY
TAG(MultiTexCoord1fv)399 TAG(MultiTexCoord1fv)(GLenum target, const GLfloat * v)
400 {
401 GET_CURRENT_CONTEXT(ctx);
402 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
403 ATTR1FV(attr, v);
404 }
405
406 static void GLAPIENTRY
TAG(MultiTexCoord2f)407 TAG(MultiTexCoord2f)(GLenum target, GLfloat x, GLfloat y)
408 {
409 GET_CURRENT_CONTEXT(ctx);
410 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
411 ATTR2F(attr, x, y);
412 }
413
414 static void GLAPIENTRY
TAG(MultiTexCoord2fv)415 TAG(MultiTexCoord2fv)(GLenum target, const GLfloat * v)
416 {
417 GET_CURRENT_CONTEXT(ctx);
418 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
419 ATTR2FV(attr, v);
420 }
421
422 static void GLAPIENTRY
TAG(MultiTexCoord3f)423 TAG(MultiTexCoord3f)(GLenum target, GLfloat x, GLfloat y, GLfloat z)
424 {
425 GET_CURRENT_CONTEXT(ctx);
426 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
427 ATTR3F(attr, x, y, z);
428 }
429
430 static void GLAPIENTRY
TAG(MultiTexCoord3fv)431 TAG(MultiTexCoord3fv)(GLenum target, const GLfloat * v)
432 {
433 GET_CURRENT_CONTEXT(ctx);
434 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
435 ATTR3FV(attr, v);
436 }
437
438 static void GLAPIENTRY
TAG(MultiTexCoord4f)439 TAG(MultiTexCoord4f)(GLenum target, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
440 {
441 GET_CURRENT_CONTEXT(ctx);
442 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
443 ATTR4F(attr, x, y, z, w);
444 }
445
446 static void GLAPIENTRY
TAG(MultiTexCoord4fv)447 TAG(MultiTexCoord4fv)(GLenum target, const GLfloat * v)
448 {
449 GET_CURRENT_CONTEXT(ctx);
450 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
451 ATTR4FV(attr, v);
452 }
453
454
455
456 static void GLAPIENTRY
TAG(VertexAttrib1fARB)457 TAG(VertexAttrib1fARB)(GLuint index, GLfloat x)
458 {
459 GET_CURRENT_CONTEXT(ctx);
460 if (index == 0)
461 ATTR1F(0, x);
462 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
463 ATTR1F(VBO_ATTRIB_GENERIC0 + index, x);
464 else
465 ERROR(GL_INVALID_VALUE);
466 }
467
468 static void GLAPIENTRY
TAG(VertexAttrib1fvARB)469 TAG(VertexAttrib1fvARB)(GLuint index, const GLfloat * v)
470 {
471 GET_CURRENT_CONTEXT(ctx);
472 if (index == 0)
473 ATTR1FV(0, v);
474 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
475 ATTR1FV(VBO_ATTRIB_GENERIC0 + index, v);
476 else
477 ERROR(GL_INVALID_VALUE);
478 }
479
480 static void GLAPIENTRY
TAG(VertexAttrib2fARB)481 TAG(VertexAttrib2fARB)(GLuint index, GLfloat x, GLfloat y)
482 {
483 GET_CURRENT_CONTEXT(ctx);
484 if (index == 0)
485 ATTR2F(0, x, y);
486 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
487 ATTR2F(VBO_ATTRIB_GENERIC0 + index, x, y);
488 else
489 ERROR(GL_INVALID_VALUE);
490 }
491
492 static void GLAPIENTRY
TAG(VertexAttrib2fvARB)493 TAG(VertexAttrib2fvARB)(GLuint index, const GLfloat * v)
494 {
495 GET_CURRENT_CONTEXT(ctx);
496 if (index == 0)
497 ATTR2FV(0, v);
498 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
499 ATTR2FV(VBO_ATTRIB_GENERIC0 + index, v);
500 else
501 ERROR(GL_INVALID_VALUE);
502 }
503
504 static void GLAPIENTRY
TAG(VertexAttrib3fARB)505 TAG(VertexAttrib3fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z)
506 {
507 GET_CURRENT_CONTEXT(ctx);
508 if (index == 0)
509 ATTR3F(0, x, y, z);
510 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
511 ATTR3F(VBO_ATTRIB_GENERIC0 + index, x, y, z);
512 else
513 ERROR(GL_INVALID_VALUE);
514 }
515
516 static void GLAPIENTRY
TAG(VertexAttrib3fvARB)517 TAG(VertexAttrib3fvARB)(GLuint index, const GLfloat * v)
518 {
519 GET_CURRENT_CONTEXT(ctx);
520 if (index == 0)
521 ATTR3FV(0, v);
522 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
523 ATTR3FV(VBO_ATTRIB_GENERIC0 + index, v);
524 else
525 ERROR(GL_INVALID_VALUE);
526 }
527
528 static void GLAPIENTRY
TAG(VertexAttrib4fARB)529 TAG(VertexAttrib4fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
530 {
531 GET_CURRENT_CONTEXT(ctx);
532 if (index == 0)
533 ATTR4F(0, x, y, z, w);
534 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
535 ATTR4F(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
536 else
537 ERROR(GL_INVALID_VALUE);
538 }
539
540 static void GLAPIENTRY
TAG(VertexAttrib4fvARB)541 TAG(VertexAttrib4fvARB)(GLuint index, const GLfloat * v)
542 {
543 GET_CURRENT_CONTEXT(ctx);
544 if (index == 0)
545 ATTR4FV(0, v);
546 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
547 ATTR4FV(VBO_ATTRIB_GENERIC0 + index, v);
548 else
549 ERROR(GL_INVALID_VALUE);
550 }
551
552
553
554 /* Integer-valued generic attributes.
555 * XXX: the integers just get converted to floats at this time
556 */
557 static void GLAPIENTRY
TAG(VertexAttribI1i)558 TAG(VertexAttribI1i)(GLuint index, GLint x)
559 {
560 GET_CURRENT_CONTEXT(ctx);
561 if (index == 0)
562 ATTR1I(0, x);
563 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
564 ATTR1I(VBO_ATTRIB_GENERIC0 + index, x);
565 else
566 ERROR(GL_INVALID_VALUE);
567 }
568
569 static void GLAPIENTRY
TAG(VertexAttribI2i)570 TAG(VertexAttribI2i)(GLuint index, GLint x, GLint y)
571 {
572 GET_CURRENT_CONTEXT(ctx);
573 if (index == 0)
574 ATTR2I(0, x, y);
575 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
576 ATTR2I(VBO_ATTRIB_GENERIC0 + index, x, y);
577 else
578 ERROR(GL_INVALID_VALUE);
579 }
580
581 static void GLAPIENTRY
TAG(VertexAttribI3i)582 TAG(VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z)
583 {
584 GET_CURRENT_CONTEXT(ctx);
585 if (index == 0)
586 ATTR3I(0, x, y, z);
587 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
588 ATTR3I(VBO_ATTRIB_GENERIC0 + index, x, y, z);
589 else
590 ERROR(GL_INVALID_VALUE);
591 }
592
593 static void GLAPIENTRY
TAG(VertexAttribI4i)594 TAG(VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w)
595 {
596 GET_CURRENT_CONTEXT(ctx);
597 if (index == 0)
598 ATTR4I(0, x, y, z, w);
599 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
600 ATTR4I(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
601 else
602 ERROR(GL_INVALID_VALUE);
603 }
604
605 static void GLAPIENTRY
TAG(VertexAttribI2iv)606 TAG(VertexAttribI2iv)(GLuint index, const GLint *v)
607 {
608 GET_CURRENT_CONTEXT(ctx);
609 if (index == 0)
610 ATTR2IV(0, v);
611 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
612 ATTR2IV(VBO_ATTRIB_GENERIC0 + index, v);
613 else
614 ERROR(GL_INVALID_VALUE);
615 }
616
617 static void GLAPIENTRY
TAG(VertexAttribI3iv)618 TAG(VertexAttribI3iv)(GLuint index, const GLint *v)
619 {
620 GET_CURRENT_CONTEXT(ctx);
621 if (index == 0)
622 ATTR3IV(0, v);
623 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
624 ATTR3IV(VBO_ATTRIB_GENERIC0 + index, v);
625 else
626 ERROR(GL_INVALID_VALUE);
627 }
628
629 static void GLAPIENTRY
TAG(VertexAttribI4iv)630 TAG(VertexAttribI4iv)(GLuint index, const GLint *v)
631 {
632 GET_CURRENT_CONTEXT(ctx);
633 if (index == 0)
634 ATTR4IV(0, v);
635 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
636 ATTR4IV(VBO_ATTRIB_GENERIC0 + index, v);
637 else
638 ERROR(GL_INVALID_VALUE);
639 }
640
641
642
643 /* Unsigned integer-valued generic attributes.
644 * XXX: the integers just get converted to floats at this time
645 */
646 static void GLAPIENTRY
TAG(VertexAttribI1ui)647 TAG(VertexAttribI1ui)(GLuint index, GLuint x)
648 {
649 GET_CURRENT_CONTEXT(ctx);
650 if (index == 0)
651 ATTR1UI(0, x);
652 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
653 ATTR1UI(VBO_ATTRIB_GENERIC0 + index, x);
654 else
655 ERROR(GL_INVALID_VALUE);
656 }
657
658 static void GLAPIENTRY
TAG(VertexAttribI2ui)659 TAG(VertexAttribI2ui)(GLuint index, GLuint x, GLuint y)
660 {
661 GET_CURRENT_CONTEXT(ctx);
662 if (index == 0)
663 ATTR2UI(0, x, y);
664 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
665 ATTR2UI(VBO_ATTRIB_GENERIC0 + index, x, y);
666 else
667 ERROR(GL_INVALID_VALUE);
668 }
669
670 static void GLAPIENTRY
TAG(VertexAttribI3ui)671 TAG(VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z)
672 {
673 GET_CURRENT_CONTEXT(ctx);
674 if (index == 0)
675 ATTR3UI(0, x, y, z);
676 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
677 ATTR3UI(VBO_ATTRIB_GENERIC0 + index, x, y, z);
678 else
679 ERROR(GL_INVALID_VALUE);
680 }
681
682 static void GLAPIENTRY
TAG(VertexAttribI4ui)683 TAG(VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
684 {
685 GET_CURRENT_CONTEXT(ctx);
686 if (index == 0)
687 ATTR4UI(0, x, y, z, w);
688 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
689 ATTR4UI(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
690 else
691 ERROR(GL_INVALID_VALUE);
692 }
693
694 static void GLAPIENTRY
TAG(VertexAttribI2uiv)695 TAG(VertexAttribI2uiv)(GLuint index, const GLuint *v)
696 {
697 GET_CURRENT_CONTEXT(ctx);
698 if (index == 0)
699 ATTR2UIV(0, v);
700 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
701 ATTR2UIV(VBO_ATTRIB_GENERIC0 + index, v);
702 else
703 ERROR(GL_INVALID_VALUE);
704 }
705
706 static void GLAPIENTRY
TAG(VertexAttribI3uiv)707 TAG(VertexAttribI3uiv)(GLuint index, const GLuint *v)
708 {
709 GET_CURRENT_CONTEXT(ctx);
710 if (index == 0)
711 ATTR3UIV(0, v);
712 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
713 ATTR3UIV(VBO_ATTRIB_GENERIC0 + index, v);
714 else
715 ERROR(GL_INVALID_VALUE);
716 }
717
718 static void GLAPIENTRY
TAG(VertexAttribI4uiv)719 TAG(VertexAttribI4uiv)(GLuint index, const GLuint *v)
720 {
721 GET_CURRENT_CONTEXT(ctx);
722 if (index == 0)
723 ATTR4UIV(0, v);
724 else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
725 ATTR4UIV(VBO_ATTRIB_GENERIC0 + index, v);
726 else
727 ERROR(GL_INVALID_VALUE);
728 }
729
730
731
732 /* In addition to supporting NV_vertex_program, these entrypoints are
733 * used by the display list and other code specifically because of
734 * their property of aliasing with other attributes. (See
735 * vbo_save_loopback.c)
736 */
737 static void GLAPIENTRY
TAG(VertexAttrib1fNV)738 TAG(VertexAttrib1fNV)(GLuint index, GLfloat x)
739 {
740 GET_CURRENT_CONTEXT(ctx);
741 if (index < VBO_ATTRIB_MAX)
742 ATTR1F(index, x);
743 }
744
745 static void GLAPIENTRY
TAG(VertexAttrib1fvNV)746 TAG(VertexAttrib1fvNV)(GLuint index, const GLfloat * v)
747 {
748 GET_CURRENT_CONTEXT(ctx);
749 if (index < VBO_ATTRIB_MAX)
750 ATTR1FV(index, v);
751 }
752
753 static void GLAPIENTRY
TAG(VertexAttrib2fNV)754 TAG(VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y)
755 {
756 GET_CURRENT_CONTEXT(ctx);
757 if (index < VBO_ATTRIB_MAX)
758 ATTR2F(index, x, y);
759 }
760
761 static void GLAPIENTRY
TAG(VertexAttrib2fvNV)762 TAG(VertexAttrib2fvNV)(GLuint index, const GLfloat * v)
763 {
764 GET_CURRENT_CONTEXT(ctx);
765 if (index < VBO_ATTRIB_MAX)
766 ATTR2FV(index, v);
767 }
768
769 static void GLAPIENTRY
TAG(VertexAttrib3fNV)770 TAG(VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z)
771 {
772 GET_CURRENT_CONTEXT(ctx);
773 if (index < VBO_ATTRIB_MAX)
774 ATTR3F(index, x, y, z);
775 }
776
777 static void GLAPIENTRY
TAG(VertexAttrib3fvNV)778 TAG(VertexAttrib3fvNV)(GLuint index,
779 const GLfloat * v)
780 {
781 GET_CURRENT_CONTEXT(ctx);
782 if (index < VBO_ATTRIB_MAX)
783 ATTR3FV(index, v);
784 }
785
786 static void GLAPIENTRY
TAG(VertexAttrib4fNV)787 TAG(VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
788 {
789 GET_CURRENT_CONTEXT(ctx);
790 if (index < VBO_ATTRIB_MAX)
791 ATTR4F(index, x, y, z, w);
792 }
793
794 static void GLAPIENTRY
TAG(VertexAttrib4fvNV)795 TAG(VertexAttrib4fvNV)(GLuint index, const GLfloat * v)
796 {
797 GET_CURRENT_CONTEXT(ctx);
798 if (index < VBO_ATTRIB_MAX)
799 ATTR4FV(index, v);
800 }
801
802
803 static void GLAPIENTRY
TAG(VertexP2ui)804 TAG(VertexP2ui)(GLenum type, GLuint value)
805 {
806 GET_CURRENT_CONTEXT(ctx);
807 ATTR_UI(2, type, 0, VBO_ATTRIB_POS, value);
808 }
809
810 static void GLAPIENTRY
TAG(VertexP2uiv)811 TAG(VertexP2uiv)(GLenum type, const GLuint *value)
812 {
813 GET_CURRENT_CONTEXT(ctx);
814 ATTR_UI(2, type, 0, VBO_ATTRIB_POS, value[0]);
815 }
816
817 static void GLAPIENTRY
TAG(VertexP3ui)818 TAG(VertexP3ui)(GLenum type, GLuint value)
819 {
820 GET_CURRENT_CONTEXT(ctx);
821 ATTR_UI(3, type, 0, VBO_ATTRIB_POS, value);
822 }
823
824 static void GLAPIENTRY
TAG(VertexP3uiv)825 TAG(VertexP3uiv)(GLenum type, const GLuint *value)
826 {
827 GET_CURRENT_CONTEXT(ctx);
828 ATTR_UI(3, type, 0, VBO_ATTRIB_POS, value[0]);
829 }
830
831 static void GLAPIENTRY
TAG(VertexP4ui)832 TAG(VertexP4ui)(GLenum type, GLuint value)
833 {
834 GET_CURRENT_CONTEXT(ctx);
835 ATTR_UI(4, type, 0, VBO_ATTRIB_POS, value);
836 }
837
838 static void GLAPIENTRY
TAG(VertexP4uiv)839 TAG(VertexP4uiv)(GLenum type, const GLuint *value)
840 {
841 GET_CURRENT_CONTEXT(ctx);
842 ATTR_UI(4, type, 0, VBO_ATTRIB_POS, value[0]);
843 }
844
845 static void GLAPIENTRY
TAG(TexCoordP1ui)846 TAG(TexCoordP1ui)(GLenum type, GLuint coords)
847 {
848 GET_CURRENT_CONTEXT(ctx);
849 ATTR_UI(1, type, 0, VBO_ATTRIB_TEX0, coords);
850 }
851
852 static void GLAPIENTRY
TAG(TexCoordP1uiv)853 TAG(TexCoordP1uiv)(GLenum type, const GLuint *coords)
854 {
855 GET_CURRENT_CONTEXT(ctx);
856 ATTR_UI(1, type, 0, VBO_ATTRIB_TEX0, coords[0]);
857 }
858
859 static void GLAPIENTRY
TAG(TexCoordP2ui)860 TAG(TexCoordP2ui)(GLenum type, GLuint coords)
861 {
862 GET_CURRENT_CONTEXT(ctx);
863 ATTR_UI(2, type, 0, VBO_ATTRIB_TEX0, coords);
864 }
865
866 static void GLAPIENTRY
TAG(TexCoordP2uiv)867 TAG(TexCoordP2uiv)(GLenum type, const GLuint *coords)
868 {
869 GET_CURRENT_CONTEXT(ctx);
870 ATTR_UI(2, type, 0, VBO_ATTRIB_TEX0, coords[0]);
871 }
872
873 static void GLAPIENTRY
TAG(TexCoordP3ui)874 TAG(TexCoordP3ui)(GLenum type, GLuint coords)
875 {
876 GET_CURRENT_CONTEXT(ctx);
877 ATTR_UI(3, type, 0, VBO_ATTRIB_TEX0, coords);
878 }
879
880 static void GLAPIENTRY
TAG(TexCoordP3uiv)881 TAG(TexCoordP3uiv)(GLenum type, const GLuint *coords)
882 {
883 GET_CURRENT_CONTEXT(ctx);
884 ATTR_UI(3, type, 0, VBO_ATTRIB_TEX0, coords[0]);
885 }
886
887 static void GLAPIENTRY
TAG(TexCoordP4ui)888 TAG(TexCoordP4ui)(GLenum type, GLuint coords)
889 {
890 GET_CURRENT_CONTEXT(ctx);
891 ATTR_UI(4, type, 0, VBO_ATTRIB_TEX0, coords);
892 }
893
894 static void GLAPIENTRY
TAG(TexCoordP4uiv)895 TAG(TexCoordP4uiv)(GLenum type, const GLuint *coords)
896 {
897 GET_CURRENT_CONTEXT(ctx);
898 ATTR_UI(4, type, 0, VBO_ATTRIB_TEX0, coords[0]);
899 }
900
901 static void GLAPIENTRY
TAG(MultiTexCoordP1ui)902 TAG(MultiTexCoordP1ui)(GLenum target, GLenum type, GLuint coords)
903 {
904 GET_CURRENT_CONTEXT(ctx);
905 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
906 ATTR_UI(1, type, 0, attr, coords);
907 }
908
909 static void GLAPIENTRY
TAG(MultiTexCoordP1uiv)910 TAG(MultiTexCoordP1uiv)(GLenum target, GLenum type, const GLuint *coords)
911 {
912 GET_CURRENT_CONTEXT(ctx);
913 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
914 ATTR_UI(1, type, 0, attr, coords[0]);
915 }
916
917 static void GLAPIENTRY
TAG(MultiTexCoordP2ui)918 TAG(MultiTexCoordP2ui)(GLenum target, GLenum type, GLuint coords)
919 {
920 GET_CURRENT_CONTEXT(ctx);
921 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
922 ATTR_UI(2, type, 0, attr, coords);
923 }
924
925 static void GLAPIENTRY
TAG(MultiTexCoordP2uiv)926 TAG(MultiTexCoordP2uiv)(GLenum target, GLenum type, const GLuint *coords)
927 {
928 GET_CURRENT_CONTEXT(ctx);
929 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
930 ATTR_UI(2, type, 0, attr, coords[0]);
931 }
932
933 static void GLAPIENTRY
TAG(MultiTexCoordP3ui)934 TAG(MultiTexCoordP3ui)(GLenum target, GLenum type, GLuint coords)
935 {
936 GET_CURRENT_CONTEXT(ctx);
937 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
938 ATTR_UI(3, type, 0, attr, coords);
939 }
940
941 static void GLAPIENTRY
TAG(MultiTexCoordP3uiv)942 TAG(MultiTexCoordP3uiv)(GLenum target, GLenum type, const GLuint *coords)
943 {
944 GET_CURRENT_CONTEXT(ctx);
945 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
946 ATTR_UI(3, type, 0, attr, coords[0]);
947 }
948
949 static void GLAPIENTRY
TAG(MultiTexCoordP4ui)950 TAG(MultiTexCoordP4ui)(GLenum target, GLenum type, GLuint coords)
951 {
952 GET_CURRENT_CONTEXT(ctx);
953 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
954 ATTR_UI(4, type, 0, attr, coords);
955 }
956
957 static void GLAPIENTRY
TAG(MultiTexCoordP4uiv)958 TAG(MultiTexCoordP4uiv)(GLenum target, GLenum type, const GLuint *coords)
959 {
960 GET_CURRENT_CONTEXT(ctx);
961 GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
962 ATTR_UI(4, type, 0, attr, coords[0]);
963 }
964
965 static void GLAPIENTRY
TAG(NormalP3ui)966 TAG(NormalP3ui)(GLenum type, GLuint coords)
967 {
968 GET_CURRENT_CONTEXT(ctx);
969 ATTR_UI(3, type, 1, VBO_ATTRIB_NORMAL, coords);
970 }
971
972 static void GLAPIENTRY
TAG(NormalP3uiv)973 TAG(NormalP3uiv)(GLenum type, const GLuint *coords)
974 {
975 GET_CURRENT_CONTEXT(ctx);
976 ATTR_UI(3, type, 1, VBO_ATTRIB_NORMAL, coords[0]);
977 }
978
979 static void GLAPIENTRY
TAG(ColorP3ui)980 TAG(ColorP3ui)(GLenum type, GLuint color)
981 {
982 GET_CURRENT_CONTEXT(ctx);
983 ATTR_UI(3, type, 1, VBO_ATTRIB_COLOR0, color);
984 }
985
986 static void GLAPIENTRY
TAG(ColorP3uiv)987 TAG(ColorP3uiv)(GLenum type, const GLuint *color)
988 {
989 GET_CURRENT_CONTEXT(ctx);
990 ATTR_UI(3, type, 1, VBO_ATTRIB_COLOR0, color[0]);
991 }
992
993 static void GLAPIENTRY
TAG(ColorP4ui)994 TAG(ColorP4ui)(GLenum type, GLuint color)
995 {
996 GET_CURRENT_CONTEXT(ctx);
997 ATTR_UI(4, type, 1, VBO_ATTRIB_COLOR0, color);
998 }
999
1000 static void GLAPIENTRY
TAG(ColorP4uiv)1001 TAG(ColorP4uiv)(GLenum type, const GLuint *color)
1002 {
1003 GET_CURRENT_CONTEXT(ctx);
1004 ATTR_UI(4, type, 1, VBO_ATTRIB_COLOR0, color[0]);
1005 }
1006
1007 static void GLAPIENTRY
TAG(SecondaryColorP3ui)1008 TAG(SecondaryColorP3ui)(GLenum type, GLuint color)
1009 {
1010 GET_CURRENT_CONTEXT(ctx);
1011 ATTR_UI(3, type, 1, VBO_ATTRIB_COLOR1, color);
1012 }
1013
1014 static void GLAPIENTRY
TAG(SecondaryColorP3uiv)1015 TAG(SecondaryColorP3uiv)(GLenum type, const GLuint *color)
1016 {
1017 GET_CURRENT_CONTEXT(ctx);
1018 ATTR_UI(3, type, 1, VBO_ATTRIB_COLOR1, color[0]);
1019 }
1020
1021 static void GLAPIENTRY
TAG(VertexAttribP1ui)1022 TAG(VertexAttribP1ui)(GLuint index, GLenum type, GLboolean normalized,
1023 GLuint value)
1024 {
1025 GET_CURRENT_CONTEXT(ctx);
1026 ATTR_UI_INDEX(1, type, normalized, index, value);
1027 }
1028
1029 static void GLAPIENTRY
TAG(VertexAttribP2ui)1030 TAG(VertexAttribP2ui)(GLuint index, GLenum type, GLboolean normalized,
1031 GLuint value)
1032 {
1033 GET_CURRENT_CONTEXT(ctx);
1034 ATTR_UI_INDEX(2, type, normalized, index, value);
1035 }
1036
1037 static void GLAPIENTRY
TAG(VertexAttribP3ui)1038 TAG(VertexAttribP3ui)(GLuint index, GLenum type, GLboolean normalized,
1039 GLuint value)
1040 {
1041 GET_CURRENT_CONTEXT(ctx);
1042 ATTR_UI_INDEX(3, type, normalized, index, value);
1043 }
1044
1045 static void GLAPIENTRY
TAG(VertexAttribP4ui)1046 TAG(VertexAttribP4ui)(GLuint index, GLenum type, GLboolean normalized,
1047 GLuint value)
1048 {
1049 GET_CURRENT_CONTEXT(ctx);
1050 ATTR_UI_INDEX(4, type, normalized, index, value);
1051 }
1052
1053 static void GLAPIENTRY
TAG(VertexAttribP1uiv)1054 TAG(VertexAttribP1uiv)(GLuint index, GLenum type, GLboolean normalized,
1055 const GLuint *value)
1056 {
1057 GET_CURRENT_CONTEXT(ctx);
1058 ATTR_UI_INDEX(1, type, normalized, index, *value);
1059 }
1060
1061 static void GLAPIENTRY
TAG(VertexAttribP2uiv)1062 TAG(VertexAttribP2uiv)(GLuint index, GLenum type, GLboolean normalized,
1063 const GLuint *value)
1064 {
1065 GET_CURRENT_CONTEXT(ctx);
1066 ATTR_UI_INDEX(2, type, normalized, index, *value);
1067 }
1068
1069 static void GLAPIENTRY
TAG(VertexAttribP3uiv)1070 TAG(VertexAttribP3uiv)(GLuint index, GLenum type, GLboolean normalized,
1071 const GLuint *value)
1072 {
1073 GET_CURRENT_CONTEXT(ctx);
1074 ATTR_UI_INDEX(3, type, normalized, index, *value);
1075 }
1076
1077 static void GLAPIENTRY
TAG(VertexAttribP4uiv)1078 TAG(VertexAttribP4uiv)(GLuint index, GLenum type, GLboolean normalized,
1079 const GLuint *value)
1080 {
1081 GET_CURRENT_CONTEXT(ctx);
1082 ATTR_UI_INDEX(4, type, normalized, index, *value);
1083 }
1084
1085
1086 #undef ATTR1FV
1087 #undef ATTR2FV
1088 #undef ATTR3FV
1089 #undef ATTR4FV
1090
1091 #undef ATTR1F
1092 #undef ATTR2F
1093 #undef ATTR3F
1094 #undef ATTR4F
1095
1096 #undef ATTR_UI
1097
1098 #undef MAT
1099