Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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