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