src/mesa/vbo/vbo_attrib_tmp.h

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