vbo_attrib_tmp.h revision b8e80941 
1/**************************************************************************
2
3Copyright 2002 VMware, Inc.
4Copyright 2011 Dave Airlie (ARB_vertex_type_2_10_10_10_rev support)
5All Rights Reserved.
6
7Permission is hereby granted, free of charge, to any person obtaining a
8copy of this software and associated documentation files (the "Software"),
9to deal in the Software without restriction, including without limitation
10on the rights to use, copy, modify, merge, publish, distribute, sub
11license, and/or sell copies of the Software, and to permit persons to whom
12the Software is furnished to do so, subject to the following conditions:
13
14The above copyright notice and this permission notice (including the next
15paragraph) shall be included in all copies or substantial portions of the
16Software.
17
18THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
22DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24USE OR OTHER DEALINGS IN THE SOFTWARE.
25
26**************************************************************************/
27
28#include "util/format_r11g11b10f.h"
29#include "main/varray.h"
30
31
32/* ATTR */
33#define ATTRI( A, N, V0, V1, V2, V3 ) \
34    ATTR_UNION(A, N, GL_INT, fi_type, INT_AS_UNION(V0), INT_AS_UNION(V1), \
35        INT_AS_UNION(V2), INT_AS_UNION(V3))
36#define ATTRUI( A, N, V0, V1, V2, V3 ) \
37    ATTR_UNION(A, N, GL_UNSIGNED_INT, fi_type, UINT_AS_UNION(V0), UINT_AS_UNION(V1), \
38        UINT_AS_UNION(V2), UINT_AS_UNION(V3))
39#define ATTRF( A, N, V0, V1, V2, V3 ) \
40    ATTR_UNION(A, N, GL_FLOAT, fi_type, FLOAT_AS_UNION(V0), FLOAT_AS_UNION(V1),\
41        FLOAT_AS_UNION(V2), FLOAT_AS_UNION(V3))
42#define ATTRD( A, N, V0, V1, V2, V3 ) \
43    ATTR_UNION(A, N, GL_DOUBLE, double, V0, V1, V2, V3)
44#define ATTRUI64( A, N, V0, V1, V2, V3 ) \
45    ATTR_UNION(A, N, GL_UNSIGNED_INT64_ARB, uint64_t, V0, V1, V2, V3)
46
47
48/* float */
49#define ATTR1FV( A, V ) ATTRF( A, 1, (V)[0], 0, 0, 1 )
50#define ATTR2FV( A, V ) ATTRF( A, 2, (V)[0], (V)[1], 0, 1 )
51#define ATTR3FV( A, V ) ATTRF( A, 3, (V)[0], (V)[1], (V)[2], 1 )
52#define ATTR4FV( A, V ) ATTRF( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
53
54#define ATTR1F( A, X )          ATTRF( A, 1, X, 0, 0, 1 )
55#define ATTR2F( A, X, Y )       ATTRF( A, 2, X, Y, 0, 1 )
56#define ATTR3F( A, X, Y, Z )    ATTRF( A, 3, X, Y, Z, 1 )
57#define ATTR4F( A, X, Y, Z, W ) ATTRF( A, 4, X, Y, Z, W )
58
59
60/* int */
61#define ATTR2IV( A, V ) ATTRI( A, 2, (V)[0], (V)[1], 0, 1 )
62#define ATTR3IV( A, V ) ATTRI( A, 3, (V)[0], (V)[1], (V)[2], 1 )
63#define ATTR4IV( A, V ) ATTRI( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
64
65#define ATTR1I( A, X )          ATTRI( A, 1, X, 0, 0, 1 )
66#define ATTR2I( A, X, Y )       ATTRI( A, 2, X, Y, 0, 1 )
67#define ATTR3I( A, X, Y, Z )    ATTRI( A, 3, X, Y, Z, 1 )
68#define ATTR4I( A, X, Y, Z, W ) ATTRI( A, 4, X, Y, Z, W )
69
70
71/* uint */
72#define ATTR2UIV( A, V ) ATTRUI( A, 2, (V)[0], (V)[1], 0, 1 )
73#define ATTR3UIV( A, V ) ATTRUI( A, 3, (V)[0], (V)[1], (V)[2], 1 )
74#define ATTR4UIV( A, V ) ATTRUI( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
75
76#define ATTR1UI( A, X )          ATTRUI( A, 1, X, 0, 0, 1 )
77#define ATTR2UI( A, X, Y )       ATTRUI( A, 2, X, Y, 0, 1 )
78#define ATTR3UI( A, X, Y, Z )    ATTRUI( A, 3, X, Y, Z, 1 )
79#define ATTR4UI( A, X, Y, Z, W ) ATTRUI( A, 4, X, Y, Z, W )
80
81#define MAT_ATTR( A, N, V ) ATTRF( A, N, (V)[0], (V)[1], (V)[2], (V)[3] )
82
83static inline float conv_ui10_to_norm_float(unsigned ui10)
84{
85   return ui10 / 1023.0f;
86}
87
88static inline float conv_ui2_to_norm_float(unsigned ui2)
89{
90   return ui2 / 3.0f;
91}
92
93#define ATTRUI10_1( A, UI ) ATTRF( A, 1, (UI) & 0x3ff, 0, 0, 1 )
94#define ATTRUI10_2( A, UI ) ATTRF( A, 2, (UI) & 0x3ff, ((UI) >> 10) & 0x3ff, 0, 1 )
95#define ATTRUI10_3( A, UI ) ATTRF( A, 3, (UI) & 0x3ff, ((UI) >> 10) & 0x3ff, ((UI) >> 20) & 0x3ff, 1 )
96#define ATTRUI10_4( A, UI ) ATTRF( A, 4, (UI) & 0x3ff, ((UI) >> 10) & 0x3ff, ((UI) >> 20) & 0x3ff, ((UI) >> 30) & 0x3 )
97
98#define ATTRUI10N_1( A, UI ) ATTRF( A, 1, conv_ui10_to_norm_float((UI) & 0x3ff), 0, 0, 1 )
99#define ATTRUI10N_2( A, UI ) ATTRF( A, 2, \
100				   conv_ui10_to_norm_float((UI) & 0x3ff), \
101				   conv_ui10_to_norm_float(((UI) >> 10) & 0x3ff), 0, 1 )
102#define ATTRUI10N_3( A, UI ) ATTRF( A, 3, \
103				   conv_ui10_to_norm_float((UI) & 0x3ff), \
104				   conv_ui10_to_norm_float(((UI) >> 10) & 0x3ff), \
105				   conv_ui10_to_norm_float(((UI) >> 20) & 0x3ff), 1 )
106#define ATTRUI10N_4( A, UI ) ATTRF( A, 4, \
107				   conv_ui10_to_norm_float((UI) & 0x3ff), \
108				   conv_ui10_to_norm_float(((UI) >> 10) & 0x3ff), \
109				   conv_ui10_to_norm_float(((UI) >> 20) & 0x3ff), \
110				   conv_ui2_to_norm_float(((UI) >> 30) & 0x3) )
111
112struct attr_bits_10 {signed int x:10;};
113struct attr_bits_2 {signed int x:2;};
114
115static inline float conv_i10_to_i(int i10)
116{
117   struct attr_bits_10 val;
118   val.x = i10;
119   return (float)val.x;
120}
121
122static inline float conv_i2_to_i(int i2)
123{
124   struct attr_bits_2 val;
125   val.x = i2;
126   return (float)val.x;
127}
128
129static inline float conv_i10_to_norm_float(const struct gl_context *ctx, int i10)
130{
131   struct attr_bits_10 val;
132   val.x = i10;
133
134   /* Traditionally, OpenGL has had two equations for converting from
135    * normalized fixed-point data to floating-point data.  In the OpenGL 3.2
136    * specification, these are equations 2.2 and 2.3, respectively:
137    *
138    *    f = (2c + 1)/(2^b - 1).                                (2.2)
139    *
140    * Comments below this equation state: "In general, this representation is
141    * used for signed normalized fixed-point parameters in GL commands, such
142    * as vertex attribute values."  Which is what we're doing here.
143    *
144    *    f = max{c/(2^(b-1) - 1), -1.0}                         (2.3)
145    *
146    * Comments below this equation state: "In general, this representation is
147    * used for signed normalized fixed-point texture or floating point values."
148    *
149    * OpenGL 4.2+ and ES 3.0 remedy this and state that equation 2.3 (above)
150    * is used in every case.  They remove equation 2.2 completely.
151    */
152   if (_mesa_is_gles3(ctx) ||
153       (_mesa_is_desktop_gl(ctx) && ctx->Version >= 42)) {
154      /* Equation 2.3 above. */
155      float f = ((float) val.x) / 511.0F;
156      return MAX2(f, -1.0f);
157   } else {
158      /* Equation 2.2 above. */
159      return (2.0F * (float)val.x + 1.0F) * (1.0F  / 1023.0F);
160   }
161}
162
163static inline float conv_i2_to_norm_float(const struct gl_context *ctx, int i2)
164{
165   struct attr_bits_2 val;
166   val.x = i2;
167
168   if (_mesa_is_gles3(ctx) ||
169       (_mesa_is_desktop_gl(ctx) && ctx->Version >= 42)) {
170      /* Equation 2.3 above. */
171      float f = (float) val.x;
172      return MAX2(f, -1.0f);
173   } else {
174      /* Equation 2.2 above. */
175      return (2.0F * (float)val.x + 1.0F) * (1.0F / 3.0F);
176   }
177}
178
179#define ATTRI10_1( A, I10 ) ATTRF( A, 1, conv_i10_to_i((I10) & 0x3ff), 0, 0, 1 )
180#define ATTRI10_2( A, I10 ) ATTRF( A, 2, \
181				conv_i10_to_i((I10) & 0x3ff),		\
182				conv_i10_to_i(((I10) >> 10) & 0x3ff), 0, 1 )
183#define ATTRI10_3( A, I10 ) ATTRF( A, 3, \
184				conv_i10_to_i((I10) & 0x3ff),	    \
185				conv_i10_to_i(((I10) >> 10) & 0x3ff), \
186				conv_i10_to_i(((I10) >> 20) & 0x3ff), 1 )
187#define ATTRI10_4( A, I10 ) ATTRF( A, 4, \
188				conv_i10_to_i((I10) & 0x3ff),		\
189				conv_i10_to_i(((I10) >> 10) & 0x3ff), \
190				conv_i10_to_i(((I10) >> 20) & 0x3ff), \
191				conv_i2_to_i(((I10) >> 30) & 0x3))
192
193
194#define ATTRI10N_1(ctx, A, I10) ATTRF(A, 1, conv_i10_to_norm_float(ctx, (I10) & 0x3ff), 0, 0, 1 )
195#define ATTRI10N_2(ctx, A, I10) ATTRF(A, 2, \
196				conv_i10_to_norm_float(ctx, (I10) & 0x3ff),		\
197				conv_i10_to_norm_float(ctx, ((I10) >> 10) & 0x3ff), 0, 1 )
198#define ATTRI10N_3(ctx, A, I10) ATTRF(A, 3, \
199				conv_i10_to_norm_float(ctx, (I10) & 0x3ff),	    \
200				conv_i10_to_norm_float(ctx, ((I10) >> 10) & 0x3ff), \
201				conv_i10_to_norm_float(ctx, ((I10) >> 20) & 0x3ff), 1 )
202#define ATTRI10N_4(ctx, A, I10) ATTRF(A, 4, \
203				conv_i10_to_norm_float(ctx, (I10) & 0x3ff),		\
204				conv_i10_to_norm_float(ctx, ((I10) >> 10) & 0x3ff), \
205				conv_i10_to_norm_float(ctx, ((I10) >> 20) & 0x3ff), \
206				conv_i2_to_norm_float(ctx, ((I10) >> 30) & 0x3))
207
208#define ATTR_UI(ctx, val, type, normalized, attr, arg) do {	\
209   if ((type) == GL_UNSIGNED_INT_2_10_10_10_REV) {		\
210      if (normalized) {						\
211	 ATTRUI10N_##val((attr), (arg));			\
212      } else {							\
213	 ATTRUI10_##val((attr), (arg));				\
214      }								\
215   } else if ((type) == GL_INT_2_10_10_10_REV) {		\
216      if (normalized) {						\
217	 ATTRI10N_##val(ctx, (attr), (arg));			\
218      } else {							\
219	 ATTRI10_##val((attr), (arg));				\
220      }								\
221   } else if ((type) == GL_UNSIGNED_INT_10F_11F_11F_REV) {	\
222      float res[4];						\
223      res[3] = 1;                                               \
224      r11g11b10f_to_float3((arg), res);				\
225      ATTR##val##FV((attr), res);				\
226   } else							\
227      ERROR(GL_INVALID_VALUE);					\
228   } while(0)
229
230#define ATTR_UI_INDEX(ctx, val, type, normalized, index, arg) do {	\
231      if ((index) == 0 && _mesa_attr_zero_aliases_vertex(ctx)) {	\
232	 ATTR_UI(ctx, val, (type), normalized, 0, (arg));		\
233      } else if ((index) < MAX_VERTEX_GENERIC_ATTRIBS) {		\
234	 ATTR_UI(ctx, val, (type), normalized, VBO_ATTRIB_GENERIC0 + (index), (arg)); \
235      } else								\
236	 ERROR(GL_INVALID_VALUE);					\
237   } while(0)
238
239
240/* Doubles */
241#define ATTR1DV( A, V ) ATTRD( A, 1, (V)[0], 0, 0, 1 )
242#define ATTR2DV( A, V ) ATTRD( A, 2, (V)[0], (V)[1], 0, 1 )
243#define ATTR3DV( A, V ) ATTRD( A, 3, (V)[0], (V)[1], (V)[2], 1 )
244#define ATTR4DV( A, V ) ATTRD( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
245
246#define ATTR1D( A, X )          ATTRD( A, 1, X, 0, 0, 1 )
247#define ATTR2D( A, X, Y )       ATTRD( A, 2, X, Y, 0, 1 )
248#define ATTR3D( A, X, Y, Z )    ATTRD( A, 3, X, Y, Z, 1 )
249#define ATTR4D( A, X, Y, Z, W ) ATTRD( A, 4, X, Y, Z, W )
250
251#define ATTR1UIV64( A, V ) ATTRUI64( A, 1, (V)[0], 0, 0, 0 )
252#define ATTR1UI64( A, X )  ATTRUI64( A, 1, X, 0, 0, 0 )
253
254
255static void GLAPIENTRY
256TAG(Vertex2f)(GLfloat x, GLfloat y)
257{
258   GET_CURRENT_CONTEXT(ctx);
259   ATTR2F(VBO_ATTRIB_POS, x, y);
260}
261
262static void GLAPIENTRY
263TAG(Vertex2fv)(const GLfloat * v)
264{
265   GET_CURRENT_CONTEXT(ctx);
266   ATTR2FV(VBO_ATTRIB_POS, v);
267}
268
269static void GLAPIENTRY
270TAG(Vertex3f)(GLfloat x, GLfloat y, GLfloat z)
271{
272   GET_CURRENT_CONTEXT(ctx);
273   ATTR3F(VBO_ATTRIB_POS, x, y, z);
274}
275
276static void GLAPIENTRY
277TAG(Vertex3fv)(const GLfloat * v)
278{
279   GET_CURRENT_CONTEXT(ctx);
280   ATTR3FV(VBO_ATTRIB_POS, v);
281}
282
283static void GLAPIENTRY
284TAG(Vertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
285{
286   GET_CURRENT_CONTEXT(ctx);
287   ATTR4F(VBO_ATTRIB_POS, x, y, z, w);
288}
289
290static void GLAPIENTRY
291TAG(Vertex4fv)(const GLfloat * v)
292{
293   GET_CURRENT_CONTEXT(ctx);
294   ATTR4FV(VBO_ATTRIB_POS, v);
295}
296
297
298
299static void GLAPIENTRY
300TAG(TexCoord1f)(GLfloat x)
301{
302   GET_CURRENT_CONTEXT(ctx);
303   ATTR1F(VBO_ATTRIB_TEX0, x);
304}
305
306static void GLAPIENTRY
307TAG(TexCoord1fv)(const GLfloat * v)
308{
309   GET_CURRENT_CONTEXT(ctx);
310   ATTR1FV(VBO_ATTRIB_TEX0, v);
311}
312
313static void GLAPIENTRY
314TAG(TexCoord2f)(GLfloat x, GLfloat y)
315{
316   GET_CURRENT_CONTEXT(ctx);
317   ATTR2F(VBO_ATTRIB_TEX0, x, y);
318}
319
320static void GLAPIENTRY
321TAG(TexCoord2fv)(const GLfloat * v)
322{
323   GET_CURRENT_CONTEXT(ctx);
324   ATTR2FV(VBO_ATTRIB_TEX0, v);
325}
326
327static void GLAPIENTRY
328TAG(TexCoord3f)(GLfloat x, GLfloat y, GLfloat z)
329{
330   GET_CURRENT_CONTEXT(ctx);
331   ATTR3F(VBO_ATTRIB_TEX0, x, y, z);
332}
333
334static void GLAPIENTRY
335TAG(TexCoord3fv)(const GLfloat * v)
336{
337   GET_CURRENT_CONTEXT(ctx);
338   ATTR3FV(VBO_ATTRIB_TEX0, v);
339}
340
341static void GLAPIENTRY
342TAG(TexCoord4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
343{
344   GET_CURRENT_CONTEXT(ctx);
345   ATTR4F(VBO_ATTRIB_TEX0, x, y, z, w);
346}
347
348static void GLAPIENTRY
349TAG(TexCoord4fv)(const GLfloat * v)
350{
351   GET_CURRENT_CONTEXT(ctx);
352   ATTR4FV(VBO_ATTRIB_TEX0, v);
353}
354
355
356
357static void GLAPIENTRY
358TAG(Normal3f)(GLfloat x, GLfloat y, GLfloat z)
359{
360   GET_CURRENT_CONTEXT(ctx);
361   ATTR3F(VBO_ATTRIB_NORMAL, x, y, z);
362}
363
364static void GLAPIENTRY
365TAG(Normal3fv)(const GLfloat * v)
366{
367   GET_CURRENT_CONTEXT(ctx);
368   ATTR3FV(VBO_ATTRIB_NORMAL, v);
369}
370
371
372
373static void GLAPIENTRY
374TAG(FogCoordfEXT)(GLfloat x)
375{
376   GET_CURRENT_CONTEXT(ctx);
377   ATTR1F(VBO_ATTRIB_FOG, x);
378}
379
380
381
382static void GLAPIENTRY
383TAG(FogCoordfvEXT)(const GLfloat * v)
384{
385   GET_CURRENT_CONTEXT(ctx);
386   ATTR1FV(VBO_ATTRIB_FOG, v);
387}
388
389static void GLAPIENTRY
390TAG(Color3f)(GLfloat x, GLfloat y, GLfloat z)
391{
392   GET_CURRENT_CONTEXT(ctx);
393   ATTR3F(VBO_ATTRIB_COLOR0, x, y, z);
394}
395
396static void GLAPIENTRY
397TAG(Color3fv)(const GLfloat * v)
398{
399   GET_CURRENT_CONTEXT(ctx);
400   ATTR3FV(VBO_ATTRIB_COLOR0, v);
401}
402
403static void GLAPIENTRY
404TAG(Color4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
405{
406   GET_CURRENT_CONTEXT(ctx);
407   ATTR4F(VBO_ATTRIB_COLOR0, x, y, z, w);
408}
409
410static void GLAPIENTRY
411TAG(Color4fv)(const GLfloat * v)
412{
413   GET_CURRENT_CONTEXT(ctx);
414   ATTR4FV(VBO_ATTRIB_COLOR0, v);
415}
416
417
418
419static void GLAPIENTRY
420TAG(SecondaryColor3fEXT)(GLfloat x, GLfloat y, GLfloat z)
421{
422   GET_CURRENT_CONTEXT(ctx);
423   ATTR3F(VBO_ATTRIB_COLOR1, x, y, z);
424}
425
426static void GLAPIENTRY
427TAG(SecondaryColor3fvEXT)(const GLfloat * v)
428{
429   GET_CURRENT_CONTEXT(ctx);
430   ATTR3FV(VBO_ATTRIB_COLOR1, v);
431}
432
433
434
435static void GLAPIENTRY
436TAG(EdgeFlag)(GLboolean b)
437{
438   GET_CURRENT_CONTEXT(ctx);
439   ATTR1F(VBO_ATTRIB_EDGEFLAG, (GLfloat) b);
440}
441
442
443
444static void GLAPIENTRY
445TAG(Indexf)(GLfloat f)
446{
447   GET_CURRENT_CONTEXT(ctx);
448   ATTR1F(VBO_ATTRIB_COLOR_INDEX, f);
449}
450
451static void GLAPIENTRY
452TAG(Indexfv)(const GLfloat * f)
453{
454   GET_CURRENT_CONTEXT(ctx);
455   ATTR1FV(VBO_ATTRIB_COLOR_INDEX, f);
456}
457
458
459
460static void GLAPIENTRY
461TAG(MultiTexCoord1f)(GLenum target, GLfloat x)
462{
463   GET_CURRENT_CONTEXT(ctx);
464   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
465   ATTR1F(attr, x);
466}
467
468static void GLAPIENTRY
469TAG(MultiTexCoord1fv)(GLenum target, const GLfloat * v)
470{
471   GET_CURRENT_CONTEXT(ctx);
472   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
473   ATTR1FV(attr, v);
474}
475
476static void GLAPIENTRY
477TAG(MultiTexCoord2f)(GLenum target, GLfloat x, GLfloat y)
478{
479   GET_CURRENT_CONTEXT(ctx);
480   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
481   ATTR2F(attr, x, y);
482}
483
484static void GLAPIENTRY
485TAG(MultiTexCoord2fv)(GLenum target, const GLfloat * v)
486{
487   GET_CURRENT_CONTEXT(ctx);
488   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
489   ATTR2FV(attr, v);
490}
491
492static void GLAPIENTRY
493TAG(MultiTexCoord3f)(GLenum target, GLfloat x, GLfloat y, GLfloat z)
494{
495   GET_CURRENT_CONTEXT(ctx);
496   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
497   ATTR3F(attr, x, y, z);
498}
499
500static void GLAPIENTRY
501TAG(MultiTexCoord3fv)(GLenum target, const GLfloat * v)
502{
503   GET_CURRENT_CONTEXT(ctx);
504   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
505   ATTR3FV(attr, v);
506}
507
508static void GLAPIENTRY
509TAG(MultiTexCoord4f)(GLenum target, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
510{
511   GET_CURRENT_CONTEXT(ctx);
512   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
513   ATTR4F(attr, x, y, z, w);
514}
515
516static void GLAPIENTRY
517TAG(MultiTexCoord4fv)(GLenum target, const GLfloat * v)
518{
519   GET_CURRENT_CONTEXT(ctx);
520   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
521   ATTR4FV(attr, v);
522}
523
524
525static void GLAPIENTRY
526TAG(VertexAttrib1fARB)(GLuint index, GLfloat x)
527{
528   GET_CURRENT_CONTEXT(ctx);
529   if (is_vertex_position(ctx, index))
530      ATTR1F(0, x);
531   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
532      ATTR1F(VBO_ATTRIB_GENERIC0 + index, x);
533   else
534      ERROR(GL_INVALID_VALUE);
535}
536
537static void GLAPIENTRY
538TAG(VertexAttrib1fvARB)(GLuint index, const GLfloat * v)
539{
540   GET_CURRENT_CONTEXT(ctx);
541   if (is_vertex_position(ctx, index))
542      ATTR1FV(0, v);
543   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
544      ATTR1FV(VBO_ATTRIB_GENERIC0 + index, v);
545   else
546      ERROR(GL_INVALID_VALUE);
547}
548
549static void GLAPIENTRY
550TAG(VertexAttrib2fARB)(GLuint index, GLfloat x, GLfloat y)
551{
552   GET_CURRENT_CONTEXT(ctx);
553   if (is_vertex_position(ctx, index))
554      ATTR2F(0, x, y);
555   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
556      ATTR2F(VBO_ATTRIB_GENERIC0 + index, x, y);
557   else
558      ERROR(GL_INVALID_VALUE);
559}
560
561static void GLAPIENTRY
562TAG(VertexAttrib2fvARB)(GLuint index, const GLfloat * v)
563{
564   GET_CURRENT_CONTEXT(ctx);
565   if (is_vertex_position(ctx, index))
566      ATTR2FV(0, v);
567   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
568      ATTR2FV(VBO_ATTRIB_GENERIC0 + index, v);
569   else
570      ERROR(GL_INVALID_VALUE);
571}
572
573static void GLAPIENTRY
574TAG(VertexAttrib3fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z)
575{
576   GET_CURRENT_CONTEXT(ctx);
577   if (is_vertex_position(ctx, index))
578      ATTR3F(0, x, y, z);
579   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
580      ATTR3F(VBO_ATTRIB_GENERIC0 + index, x, y, z);
581   else
582      ERROR(GL_INVALID_VALUE);
583}
584
585static void GLAPIENTRY
586TAG(VertexAttrib3fvARB)(GLuint index, const GLfloat * v)
587{
588   GET_CURRENT_CONTEXT(ctx);
589   if (is_vertex_position(ctx, index))
590      ATTR3FV(0, v);
591   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
592      ATTR3FV(VBO_ATTRIB_GENERIC0 + index, v);
593   else
594      ERROR(GL_INVALID_VALUE);
595}
596
597static void GLAPIENTRY
598TAG(VertexAttrib4fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
599{
600   GET_CURRENT_CONTEXT(ctx);
601   if (is_vertex_position(ctx, index))
602      ATTR4F(0, x, y, z, w);
603   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
604      ATTR4F(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
605   else
606      ERROR(GL_INVALID_VALUE);
607}
608
609static void GLAPIENTRY
610TAG(VertexAttrib4fvARB)(GLuint index, const GLfloat * v)
611{
612   GET_CURRENT_CONTEXT(ctx);
613   if (is_vertex_position(ctx, index))
614      ATTR4FV(0, v);
615   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
616      ATTR4FV(VBO_ATTRIB_GENERIC0 + index, v);
617   else
618      ERROR(GL_INVALID_VALUE);
619}
620
621
622
623/* Integer-valued generic attributes.
624 * XXX: the integers just get converted to floats at this time
625 */
626static void GLAPIENTRY
627TAG(VertexAttribI1i)(GLuint index, GLint x)
628{
629   GET_CURRENT_CONTEXT(ctx);
630   if (is_vertex_position(ctx, index))
631      ATTR1I(0, x);
632   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
633      ATTR1I(VBO_ATTRIB_GENERIC0 + index, x);
634   else
635      ERROR(GL_INVALID_VALUE);
636}
637
638static void GLAPIENTRY
639TAG(VertexAttribI2i)(GLuint index, GLint x, GLint y)
640{
641   GET_CURRENT_CONTEXT(ctx);
642   if (is_vertex_position(ctx, index))
643      ATTR2I(0, x, y);
644   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
645      ATTR2I(VBO_ATTRIB_GENERIC0 + index, x, y);
646   else
647      ERROR(GL_INVALID_VALUE);
648}
649
650static void GLAPIENTRY
651TAG(VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z)
652{
653   GET_CURRENT_CONTEXT(ctx);
654   if (is_vertex_position(ctx, index))
655      ATTR3I(0, x, y, z);
656   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
657      ATTR3I(VBO_ATTRIB_GENERIC0 + index, x, y, z);
658   else
659      ERROR(GL_INVALID_VALUE);
660}
661
662static void GLAPIENTRY
663TAG(VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w)
664{
665   GET_CURRENT_CONTEXT(ctx);
666   if (is_vertex_position(ctx, index))
667      ATTR4I(0, x, y, z, w);
668   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
669      ATTR4I(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
670   else
671      ERROR(GL_INVALID_VALUE);
672}
673
674static void GLAPIENTRY
675TAG(VertexAttribI2iv)(GLuint index, const GLint *v)
676{
677   GET_CURRENT_CONTEXT(ctx);
678   if (is_vertex_position(ctx, index))
679      ATTR2IV(0, v);
680   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
681      ATTR2IV(VBO_ATTRIB_GENERIC0 + index, v);
682   else
683      ERROR(GL_INVALID_VALUE);
684}
685
686static void GLAPIENTRY
687TAG(VertexAttribI3iv)(GLuint index, const GLint *v)
688{
689   GET_CURRENT_CONTEXT(ctx);
690   if (is_vertex_position(ctx, index))
691      ATTR3IV(0, v);
692   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
693      ATTR3IV(VBO_ATTRIB_GENERIC0 + index, v);
694   else
695      ERROR(GL_INVALID_VALUE);
696}
697
698static void GLAPIENTRY
699TAG(VertexAttribI4iv)(GLuint index, const GLint *v)
700{
701   GET_CURRENT_CONTEXT(ctx);
702   if (is_vertex_position(ctx, index))
703      ATTR4IV(0, v);
704   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
705      ATTR4IV(VBO_ATTRIB_GENERIC0 + index, v);
706   else
707      ERROR(GL_INVALID_VALUE);
708}
709
710
711
712/* Unsigned integer-valued generic attributes.
713 * XXX: the integers just get converted to floats at this time
714 */
715static void GLAPIENTRY
716TAG(VertexAttribI1ui)(GLuint index, GLuint x)
717{
718   GET_CURRENT_CONTEXT(ctx);
719   if (is_vertex_position(ctx, index))
720      ATTR1UI(0, x);
721   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
722      ATTR1UI(VBO_ATTRIB_GENERIC0 + index, x);
723   else
724      ERROR(GL_INVALID_VALUE);
725}
726
727static void GLAPIENTRY
728TAG(VertexAttribI2ui)(GLuint index, GLuint x, GLuint y)
729{
730   GET_CURRENT_CONTEXT(ctx);
731   if (is_vertex_position(ctx, index))
732      ATTR2UI(0, x, y);
733   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
734      ATTR2UI(VBO_ATTRIB_GENERIC0 + index, x, y);
735   else
736      ERROR(GL_INVALID_VALUE);
737}
738
739static void GLAPIENTRY
740TAG(VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z)
741{
742   GET_CURRENT_CONTEXT(ctx);
743   if (is_vertex_position(ctx, index))
744      ATTR3UI(0, x, y, z);
745   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
746      ATTR3UI(VBO_ATTRIB_GENERIC0 + index, x, y, z);
747   else
748      ERROR(GL_INVALID_VALUE);
749}
750
751static void GLAPIENTRY
752TAG(VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
753{
754   GET_CURRENT_CONTEXT(ctx);
755   if (is_vertex_position(ctx, index))
756      ATTR4UI(0, x, y, z, w);
757   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
758      ATTR4UI(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
759   else
760      ERROR(GL_INVALID_VALUE);
761}
762
763static void GLAPIENTRY
764TAG(VertexAttribI2uiv)(GLuint index, const GLuint *v)
765{
766   GET_CURRENT_CONTEXT(ctx);
767   if (is_vertex_position(ctx, index))
768      ATTR2UIV(0, v);
769   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
770      ATTR2UIV(VBO_ATTRIB_GENERIC0 + index, v);
771   else
772      ERROR(GL_INVALID_VALUE);
773}
774
775static void GLAPIENTRY
776TAG(VertexAttribI3uiv)(GLuint index, const GLuint *v)
777{
778   GET_CURRENT_CONTEXT(ctx);
779   if (is_vertex_position(ctx, index))
780      ATTR3UIV(0, v);
781   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
782      ATTR3UIV(VBO_ATTRIB_GENERIC0 + index, v);
783   else
784      ERROR(GL_INVALID_VALUE);
785}
786
787static void GLAPIENTRY
788TAG(VertexAttribI4uiv)(GLuint index, const GLuint *v)
789{
790   GET_CURRENT_CONTEXT(ctx);
791   if (is_vertex_position(ctx, index))
792      ATTR4UIV(0, v);
793   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
794      ATTR4UIV(VBO_ATTRIB_GENERIC0 + index, v);
795   else
796      ERROR(GL_INVALID_VALUE);
797}
798
799
800
801/* These entrypoints are no longer used for NV_vertex_program but they are
802 * used by the display list and other code specifically because of their
803 * property of aliasing with the legacy Vertex, TexCoord, Normal, etc
804 * attributes.  (See vbo_save_loopback.c)
805 */
806static void GLAPIENTRY
807TAG(VertexAttrib1fNV)(GLuint index, GLfloat x)
808{
809   GET_CURRENT_CONTEXT(ctx);
810   if (index < VBO_ATTRIB_MAX)
811      ATTR1F(index, x);
812}
813
814static void GLAPIENTRY
815TAG(VertexAttrib1fvNV)(GLuint index, const GLfloat * v)
816{
817   GET_CURRENT_CONTEXT(ctx);
818   if (index < VBO_ATTRIB_MAX)
819      ATTR1FV(index, v);
820}
821
822static void GLAPIENTRY
823TAG(VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y)
824{
825   GET_CURRENT_CONTEXT(ctx);
826   if (index < VBO_ATTRIB_MAX)
827      ATTR2F(index, x, y);
828}
829
830static void GLAPIENTRY
831TAG(VertexAttrib2fvNV)(GLuint index, const GLfloat * v)
832{
833   GET_CURRENT_CONTEXT(ctx);
834   if (index < VBO_ATTRIB_MAX)
835      ATTR2FV(index, v);
836}
837
838static void GLAPIENTRY
839TAG(VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z)
840{
841   GET_CURRENT_CONTEXT(ctx);
842   if (index < VBO_ATTRIB_MAX)
843      ATTR3F(index, x, y, z);
844}
845
846static void GLAPIENTRY
847TAG(VertexAttrib3fvNV)(GLuint index,
848 const GLfloat * v)
849{
850   GET_CURRENT_CONTEXT(ctx);
851   if (index < VBO_ATTRIB_MAX)
852      ATTR3FV(index, v);
853}
854
855static void GLAPIENTRY
856TAG(VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
857{
858   GET_CURRENT_CONTEXT(ctx);
859   if (index < VBO_ATTRIB_MAX)
860      ATTR4F(index, x, y, z, w);
861}
862
863static void GLAPIENTRY
864TAG(VertexAttrib4fvNV)(GLuint index, const GLfloat * v)
865{
866   GET_CURRENT_CONTEXT(ctx);
867   if (index < VBO_ATTRIB_MAX)
868      ATTR4FV(index, v);
869}
870
871
872#define ERROR_IF_NOT_PACKED_TYPE(ctx, type, func) \
873   if (type != GL_INT_2_10_10_10_REV && type != GL_UNSIGNED_INT_2_10_10_10_REV) { \
874      _mesa_error(ctx, GL_INVALID_ENUM, "%s(type)", func); \
875      return; \
876   }
877
878/* Extended version of ERROR_IF_NOT_PACKED_TYPE which also
879 * accepts GL_UNSIGNED_INT_10F_11F_11F_REV.
880 *
881 * Only used for VertexAttribP[123]ui[v]; VertexAttribP4* cannot use this type,
882 * and neither can legacy vertex attribs.
883 */
884#define ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, func) \
885   if (type != GL_INT_2_10_10_10_REV && type != GL_UNSIGNED_INT_2_10_10_10_REV && \
886       type != GL_UNSIGNED_INT_10F_11F_11F_REV) { \
887      _mesa_error(ctx, GL_INVALID_ENUM, "%s(type)", func); \
888      return; \
889   }
890
891static void GLAPIENTRY
892TAG(VertexP2ui)(GLenum type, GLuint value)
893{
894   GET_CURRENT_CONTEXT(ctx);
895   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexP2ui");
896   ATTR_UI(ctx, 2, type, 0, VBO_ATTRIB_POS, value);
897}
898
899static void GLAPIENTRY
900TAG(VertexP2uiv)(GLenum type, const GLuint *value)
901{
902   GET_CURRENT_CONTEXT(ctx);
903   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexP2uiv");
904   ATTR_UI(ctx, 2, type, 0, VBO_ATTRIB_POS, value[0]);
905}
906
907static void GLAPIENTRY
908TAG(VertexP3ui)(GLenum type, GLuint value)
909{
910   GET_CURRENT_CONTEXT(ctx);
911   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexP3ui");
912   ATTR_UI(ctx, 3, type, 0, VBO_ATTRIB_POS, value);
913}
914
915static void GLAPIENTRY
916TAG(VertexP3uiv)(GLenum type, const GLuint *value)
917{
918   GET_CURRENT_CONTEXT(ctx);
919   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexP3uiv");
920   ATTR_UI(ctx, 3, type, 0, VBO_ATTRIB_POS, value[0]);
921}
922
923static void GLAPIENTRY
924TAG(VertexP4ui)(GLenum type, GLuint value)
925{
926   GET_CURRENT_CONTEXT(ctx);
927   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexP4ui");
928   ATTR_UI(ctx, 4, type, 0, VBO_ATTRIB_POS, value);
929}
930
931static void GLAPIENTRY
932TAG(VertexP4uiv)(GLenum type, const GLuint *value)
933{
934   GET_CURRENT_CONTEXT(ctx);
935   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexP4uiv");
936   ATTR_UI(ctx, 4, type, 0, VBO_ATTRIB_POS, value[0]);
937}
938
939static void GLAPIENTRY
940TAG(TexCoordP1ui)(GLenum type, GLuint coords)
941{
942   GET_CURRENT_CONTEXT(ctx);
943   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP1ui");
944   ATTR_UI(ctx, 1, type, 0, VBO_ATTRIB_TEX0, coords);
945}
946
947static void GLAPIENTRY
948TAG(TexCoordP1uiv)(GLenum type, const GLuint *coords)
949{
950   GET_CURRENT_CONTEXT(ctx);
951   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP1uiv");
952   ATTR_UI(ctx, 1, type, 0, VBO_ATTRIB_TEX0, coords[0]);
953}
954
955static void GLAPIENTRY
956TAG(TexCoordP2ui)(GLenum type, GLuint coords)
957{
958   GET_CURRENT_CONTEXT(ctx);
959   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP2ui");
960   ATTR_UI(ctx, 2, type, 0, VBO_ATTRIB_TEX0, coords);
961}
962
963static void GLAPIENTRY
964TAG(TexCoordP2uiv)(GLenum type, const GLuint *coords)
965{
966   GET_CURRENT_CONTEXT(ctx);
967   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP2uiv");
968   ATTR_UI(ctx, 2, type, 0, VBO_ATTRIB_TEX0, coords[0]);
969}
970
971static void GLAPIENTRY
972TAG(TexCoordP3ui)(GLenum type, GLuint coords)
973{
974   GET_CURRENT_CONTEXT(ctx);
975   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP3ui");
976   ATTR_UI(ctx, 3, type, 0, VBO_ATTRIB_TEX0, coords);
977}
978
979static void GLAPIENTRY
980TAG(TexCoordP3uiv)(GLenum type, const GLuint *coords)
981{
982   GET_CURRENT_CONTEXT(ctx);
983   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP3uiv");
984   ATTR_UI(ctx, 3, type, 0, VBO_ATTRIB_TEX0, coords[0]);
985}
986
987static void GLAPIENTRY
988TAG(TexCoordP4ui)(GLenum type, GLuint coords)
989{
990   GET_CURRENT_CONTEXT(ctx);
991   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP4ui");
992   ATTR_UI(ctx, 4, type, 0, VBO_ATTRIB_TEX0, coords);
993}
994
995static void GLAPIENTRY
996TAG(TexCoordP4uiv)(GLenum type, const GLuint *coords)
997{
998   GET_CURRENT_CONTEXT(ctx);
999   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glTexCoordP4uiv");
1000   ATTR_UI(ctx, 4, type, 0, VBO_ATTRIB_TEX0, coords[0]);
1001}
1002
1003static void GLAPIENTRY
1004TAG(MultiTexCoordP1ui)(GLenum target, GLenum type, GLuint coords)
1005{
1006   GET_CURRENT_CONTEXT(ctx);
1007   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
1008   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP1ui");
1009   ATTR_UI(ctx, 1, type, 0, attr, coords);
1010}
1011
1012static void GLAPIENTRY
1013TAG(MultiTexCoordP1uiv)(GLenum target, GLenum type, const GLuint *coords)
1014{
1015   GET_CURRENT_CONTEXT(ctx);
1016   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
1017   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP1uiv");
1018   ATTR_UI(ctx, 1, type, 0, attr, coords[0]);
1019}
1020
1021static void GLAPIENTRY
1022TAG(MultiTexCoordP2ui)(GLenum target, GLenum type, GLuint coords)
1023{
1024   GET_CURRENT_CONTEXT(ctx);
1025   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
1026   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP2ui");
1027   ATTR_UI(ctx, 2, type, 0, attr, coords);
1028}
1029
1030static void GLAPIENTRY
1031TAG(MultiTexCoordP2uiv)(GLenum target, GLenum type, const GLuint *coords)
1032{
1033   GET_CURRENT_CONTEXT(ctx);
1034   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
1035   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP2uiv");
1036   ATTR_UI(ctx, 2, type, 0, attr, coords[0]);
1037}
1038
1039static void GLAPIENTRY
1040TAG(MultiTexCoordP3ui)(GLenum target, GLenum type, GLuint coords)
1041{
1042   GET_CURRENT_CONTEXT(ctx);
1043   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
1044   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP3ui");
1045   ATTR_UI(ctx, 3, type, 0, attr, coords);
1046}
1047
1048static void GLAPIENTRY
1049TAG(MultiTexCoordP3uiv)(GLenum target, GLenum type, const GLuint *coords)
1050{
1051   GET_CURRENT_CONTEXT(ctx);
1052   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
1053   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP3uiv");
1054   ATTR_UI(ctx, 3, type, 0, attr, coords[0]);
1055}
1056
1057static void GLAPIENTRY
1058TAG(MultiTexCoordP4ui)(GLenum target, GLenum type, GLuint coords)
1059{
1060   GET_CURRENT_CONTEXT(ctx);
1061   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
1062   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP4ui");
1063   ATTR_UI(ctx, 4, type, 0, attr, coords);
1064}
1065
1066static void GLAPIENTRY
1067TAG(MultiTexCoordP4uiv)(GLenum target, GLenum type, const GLuint *coords)
1068{
1069   GET_CURRENT_CONTEXT(ctx);
1070   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
1071   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glMultiTexCoordP4uiv");
1072   ATTR_UI(ctx, 4, type, 0, attr, coords[0]);
1073}
1074
1075static void GLAPIENTRY
1076TAG(NormalP3ui)(GLenum type, GLuint coords)
1077{
1078   GET_CURRENT_CONTEXT(ctx);
1079   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glNormalP3ui");
1080   ATTR_UI(ctx, 3, type, 1, VBO_ATTRIB_NORMAL, coords);
1081}
1082
1083static void GLAPIENTRY
1084TAG(NormalP3uiv)(GLenum type, const GLuint *coords)
1085{
1086   GET_CURRENT_CONTEXT(ctx);
1087   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glNormalP3uiv");
1088   ATTR_UI(ctx, 3, type, 1, VBO_ATTRIB_NORMAL, coords[0]);
1089}
1090
1091static void GLAPIENTRY
1092TAG(ColorP3ui)(GLenum type, GLuint color)
1093{
1094   GET_CURRENT_CONTEXT(ctx);
1095   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glColorP3ui");
1096   ATTR_UI(ctx, 3, type, 1, VBO_ATTRIB_COLOR0, color);
1097}
1098
1099static void GLAPIENTRY
1100TAG(ColorP3uiv)(GLenum type, const GLuint *color)
1101{
1102   GET_CURRENT_CONTEXT(ctx);
1103   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glColorP3uiv");
1104   ATTR_UI(ctx, 3, type, 1, VBO_ATTRIB_COLOR0, color[0]);
1105}
1106
1107static void GLAPIENTRY
1108TAG(ColorP4ui)(GLenum type, GLuint color)
1109{
1110   GET_CURRENT_CONTEXT(ctx);
1111   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glColorP4ui");
1112   ATTR_UI(ctx, 4, type, 1, VBO_ATTRIB_COLOR0, color);
1113}
1114
1115static void GLAPIENTRY
1116TAG(ColorP4uiv)(GLenum type, const GLuint *color)
1117{
1118   GET_CURRENT_CONTEXT(ctx);
1119   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glColorP4uiv");
1120   ATTR_UI(ctx, 4, type, 1, VBO_ATTRIB_COLOR0, color[0]);
1121}
1122
1123static void GLAPIENTRY
1124TAG(SecondaryColorP3ui)(GLenum type, GLuint color)
1125{
1126   GET_CURRENT_CONTEXT(ctx);
1127   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glSecondaryColorP3ui");
1128   ATTR_UI(ctx, 3, type, 1, VBO_ATTRIB_COLOR1, color);
1129}
1130
1131static void GLAPIENTRY
1132TAG(SecondaryColorP3uiv)(GLenum type, const GLuint *color)
1133{
1134   GET_CURRENT_CONTEXT(ctx);
1135   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glSecondaryColorP3uiv");
1136   ATTR_UI(ctx, 3, type, 1, VBO_ATTRIB_COLOR1, color[0]);
1137}
1138
1139static void GLAPIENTRY
1140TAG(VertexAttribP1ui)(GLuint index, GLenum type, GLboolean normalized,
1141		      GLuint value)
1142{
1143   GET_CURRENT_CONTEXT(ctx);
1144   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP1ui");
1145   ATTR_UI_INDEX(ctx, 1, type, normalized, index, value);
1146}
1147
1148static void GLAPIENTRY
1149TAG(VertexAttribP2ui)(GLuint index, GLenum type, GLboolean normalized,
1150		      GLuint value)
1151{
1152   GET_CURRENT_CONTEXT(ctx);
1153   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP2ui");
1154   ATTR_UI_INDEX(ctx, 2, type, normalized, index, value);
1155}
1156
1157static void GLAPIENTRY
1158TAG(VertexAttribP3ui)(GLuint index, GLenum type, GLboolean normalized,
1159		      GLuint value)
1160{
1161   GET_CURRENT_CONTEXT(ctx);
1162   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP3ui");
1163   ATTR_UI_INDEX(ctx, 3, type, normalized, index, value);
1164}
1165
1166static void GLAPIENTRY
1167TAG(VertexAttribP4ui)(GLuint index, GLenum type, GLboolean normalized,
1168		      GLuint value)
1169{
1170   GET_CURRENT_CONTEXT(ctx);
1171   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexAttribP4ui");
1172   ATTR_UI_INDEX(ctx, 4, type, normalized, index, value);
1173}
1174
1175static void GLAPIENTRY
1176TAG(VertexAttribP1uiv)(GLuint index, GLenum type, GLboolean normalized,
1177		       const GLuint *value)
1178{
1179   GET_CURRENT_CONTEXT(ctx);
1180   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP1uiv");
1181   ATTR_UI_INDEX(ctx, 1, type, normalized, index, *value);
1182}
1183
1184static void GLAPIENTRY
1185TAG(VertexAttribP2uiv)(GLuint index, GLenum type, GLboolean normalized,
1186		       const GLuint *value)
1187{
1188   GET_CURRENT_CONTEXT(ctx);
1189   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP2uiv");
1190   ATTR_UI_INDEX(ctx, 2, type, normalized, index, *value);
1191}
1192
1193static void GLAPIENTRY
1194TAG(VertexAttribP3uiv)(GLuint index, GLenum type, GLboolean normalized,
1195		       const GLuint *value)
1196{
1197   GET_CURRENT_CONTEXT(ctx);
1198   ERROR_IF_NOT_PACKED_TYPE_EXT(ctx, type, "glVertexAttribP3uiv");
1199   ATTR_UI_INDEX(ctx, 3, type, normalized, index, *value);
1200}
1201
1202static void GLAPIENTRY
1203TAG(VertexAttribP4uiv)(GLuint index, GLenum type, GLboolean normalized,
1204		      const GLuint *value)
1205{
1206   GET_CURRENT_CONTEXT(ctx);
1207   ERROR_IF_NOT_PACKED_TYPE(ctx, type, "glVertexAttribP4uiv");
1208   ATTR_UI_INDEX(ctx, 4, type, normalized, index, *value);
1209}
1210
1211
1212
1213static void GLAPIENTRY
1214TAG(VertexAttribL1d)(GLuint index, GLdouble x)
1215{
1216   GET_CURRENT_CONTEXT(ctx);
1217   if (is_vertex_position(ctx, index))
1218      ATTR1D(0, x);
1219   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1220      ATTR1D(VBO_ATTRIB_GENERIC0 + index, x);
1221   else
1222      ERROR(GL_INVALID_VALUE);
1223}
1224
1225static void GLAPIENTRY
1226TAG(VertexAttribL1dv)(GLuint index, const GLdouble * v)
1227{
1228   GET_CURRENT_CONTEXT(ctx);
1229   if (is_vertex_position(ctx, index))
1230      ATTR1DV(0, v);
1231   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1232      ATTR1DV(VBO_ATTRIB_GENERIC0 + index, v);
1233   else
1234      ERROR(GL_INVALID_VALUE);
1235}
1236
1237static void GLAPIENTRY
1238TAG(VertexAttribL2d)(GLuint index, GLdouble x, GLdouble y)
1239{
1240   GET_CURRENT_CONTEXT(ctx);
1241   if (is_vertex_position(ctx, index))
1242      ATTR2D(0, x, y);
1243   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1244      ATTR2D(VBO_ATTRIB_GENERIC0 + index, x, y);
1245   else
1246      ERROR(GL_INVALID_VALUE);
1247}
1248
1249static void GLAPIENTRY
1250TAG(VertexAttribL2dv)(GLuint index, const GLdouble * v)
1251{
1252   GET_CURRENT_CONTEXT(ctx);
1253   if (is_vertex_position(ctx, index))
1254      ATTR2DV(0, v);
1255   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1256      ATTR2DV(VBO_ATTRIB_GENERIC0 + index, v);
1257   else
1258      ERROR(GL_INVALID_VALUE);
1259}
1260
1261static void GLAPIENTRY
1262TAG(VertexAttribL3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z)
1263{
1264   GET_CURRENT_CONTEXT(ctx);
1265   if (is_vertex_position(ctx, index))
1266      ATTR3D(0, x, y, z);
1267   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1268      ATTR3D(VBO_ATTRIB_GENERIC0 + index, x, y, z);
1269   else
1270      ERROR(GL_INVALID_VALUE);
1271}
1272
1273static void GLAPIENTRY
1274TAG(VertexAttribL3dv)(GLuint index, const GLdouble * v)
1275{
1276   GET_CURRENT_CONTEXT(ctx);
1277   if (is_vertex_position(ctx, index))
1278      ATTR3DV(0, v);
1279   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1280      ATTR3DV(VBO_ATTRIB_GENERIC0 + index, v);
1281   else
1282      ERROR(GL_INVALID_VALUE);
1283}
1284
1285static void GLAPIENTRY
1286TAG(VertexAttribL4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1287{
1288   GET_CURRENT_CONTEXT(ctx);
1289   if (is_vertex_position(ctx, index))
1290      ATTR4D(0, x, y, z, w);
1291   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1292      ATTR4D(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
1293   else
1294      ERROR(GL_INVALID_VALUE);
1295}
1296
1297static void GLAPIENTRY
1298TAG(VertexAttribL4dv)(GLuint index, const GLdouble * v)
1299{
1300   GET_CURRENT_CONTEXT(ctx);
1301   if (is_vertex_position(ctx, index))
1302      ATTR4DV(0, v);
1303   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1304      ATTR4DV(VBO_ATTRIB_GENERIC0 + index, v);
1305   else
1306      ERROR(GL_INVALID_VALUE);
1307}
1308
1309static void GLAPIENTRY
1310TAG(VertexAttribL1ui64ARB)(GLuint index, GLuint64EXT x)
1311{
1312   GET_CURRENT_CONTEXT(ctx);
1313   if (is_vertex_position(ctx, index))
1314      ATTR1UI64(0, x);
1315   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1316      ATTR1UI64(VBO_ATTRIB_GENERIC0 + index, x);
1317   else
1318      ERROR(GL_INVALID_VALUE);
1319}
1320
1321static void GLAPIENTRY
1322TAG(VertexAttribL1ui64vARB)(GLuint index, const GLuint64EXT *v)
1323{
1324   GET_CURRENT_CONTEXT(ctx);
1325   if (is_vertex_position(ctx, index))
1326      ATTR1UIV64(0, v);
1327   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1328      ATTR1UIV64(VBO_ATTRIB_GENERIC0 + index, v);
1329   else
1330      ERROR(GL_INVALID_VALUE);
1331}
1332
1333#undef ATTR1FV
1334#undef ATTR2FV
1335#undef ATTR3FV
1336#undef ATTR4FV
1337
1338#undef ATTR1F
1339#undef ATTR2F
1340#undef ATTR3F
1341#undef ATTR4F
1342
1343#undef ATTR_UI
1344
1345#undef MAT
1346