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