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