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