Subversion Repositories Kolibri OS

Rev

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

  1. /*
  2.  * Mesa 3-D graphics library
  3.  * Version:  7.7
  4.  *
  5.  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
  6.  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
  7.  *
  8.  * Permission is hereby granted, free of charge, to any person obtaining a
  9.  * copy of this software and associated documentation files (the "Software"),
  10.  * to deal in the Software without restriction, including without limitation
  11.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12.  * and/or sell copies of the Software, and to permit persons to whom the
  13.  * Software is furnished to do so, subject to the following conditions:
  14.  *
  15.  * The above copyright notice and this permission notice shall be included
  16.  * in all copies or substantial portions of the Software.
  17.  *
  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24.  */
  25.  
  26. /**
  27.  * \file mtypes.h
  28.  * Main Mesa data structures.
  29.  *
  30.  * Please try to mark derived values with a leading underscore ('_').
  31.  */
  32.  
  33. #ifndef MTYPES_H
  34. #define MTYPES_H
  35.  
  36.  
  37. #include "main/glheader.h"
  38. #include "main/config.h"
  39. #include "main/mfeatures.h"
  40. #include "glapi/glapi.h"
  41. #include "math/m_matrix.h"      /* GLmatrix */
  42. #include "main/simple_list.h"   /* struct simple_node */
  43.  
  44.  
  45. /**
  46.  * Color channel data type.
  47.  */
  48. #if CHAN_BITS == 8
  49.    typedef GLubyte GLchan;
  50. #define CHAN_MAX 255
  51. #define CHAN_MAXF 255.0F
  52. #define CHAN_TYPE GL_UNSIGNED_BYTE
  53. #elif CHAN_BITS == 16
  54.    typedef GLushort GLchan;
  55. #define CHAN_MAX 65535
  56. #define CHAN_MAXF 65535.0F
  57. #define CHAN_TYPE GL_UNSIGNED_SHORT
  58. #elif CHAN_BITS == 32
  59.    typedef GLfloat GLchan;
  60. #define CHAN_MAX 1.0
  61. #define CHAN_MAXF 1.0F
  62. #define CHAN_TYPE GL_FLOAT
  63. #else
  64. #error "illegal number of color channel bits"
  65. #endif
  66.  
  67.  
  68. /**
  69.  * Stencil buffer data type.
  70.  */
  71. #if STENCIL_BITS==8
  72.    typedef GLubyte GLstencil;
  73. #elif STENCIL_BITS==16
  74.    typedef GLushort GLstencil;
  75. #else
  76. #  error "illegal number of stencil bits"
  77. #endif
  78.  
  79.  
  80. /**
  81.  * \name 64-bit extension of GLbitfield.
  82.  */
  83. /*@{*/
  84. typedef GLuint64 GLbitfield64;
  85.  
  86. #define BITFIELD64_ONE         1ULL
  87. #define BITFIELD64_ALLONES     ~0ULL
  88.  
  89. /** Set a single bit */
  90. #define BITFIELD64_BIT(b)      (BITFIELD64_ONE << (b))
  91.  
  92. /** Set a mask of the least significant \c b bits */
  93. #define BITFIELD64_MASK(b)     (((b) >= 64) ? BITFIELD64_ALLONES : \
  94.                                 (BITFIELD64_BIT(b) - 1))
  95.  
  96. /**
  97.  * Set all bits from l (low bit) to h (high bit), inclusive.
  98.  *
  99.  * \note \C BITFIELD_64_RANGE(0, 63) return 64 set bits.
  100.  */
  101. #define BITFIELD64_RANGE(l, h) (BITFIELD64_MASK((h) + 1) & ~BITFIELD64_MASK(l))
  102. /*@}*/
  103.  
  104.  
  105. /**
  106.  * \name Some forward type declarations
  107.  */
  108. /*@{*/
  109. struct _mesa_HashTable;
  110. struct gl_attrib_node;
  111. struct gl_list_extensions;
  112. struct gl_meta_state;
  113. struct gl_pixelstore_attrib;
  114. struct gl_program_cache;
  115. struct gl_texture_format;
  116. struct gl_texture_image;
  117. struct gl_texture_object;
  118. struct gl_context;
  119. struct st_context;
  120. /*@}*/
  121.  
  122.  
  123.  
  124. /**
  125.  * Shader stages. Note that these will become 5 with tessellation.
  126.  * These MUST have the same values as gallium's PIPE_SHADER_*
  127.  */
  128. typedef enum
  129. {
  130.    MESA_SHADER_VERTEX = 0,
  131.    MESA_SHADER_FRAGMENT = 1,
  132.    MESA_SHADER_GEOMETRY = 2,
  133.    MESA_SHADER_TYPES = 3
  134. } gl_shader_type;
  135.  
  136.  
  137.  
  138. /**
  139.  * Indexes for vertex program attributes.
  140.  * GL_NV_vertex_program aliases generic attributes over the conventional
  141.  * attributes.  In GL_ARB_vertex_program shader the aliasing is optional.
  142.  * In GL_ARB_vertex_shader / OpenGL 2.0 the aliasing is disallowed (the
  143.  * generic attributes are distinct/separate).
  144.  */
  145. typedef enum
  146. {
  147.    VERT_ATTRIB_POS = 0,
  148.    VERT_ATTRIB_WEIGHT = 1,
  149.    VERT_ATTRIB_NORMAL = 2,
  150.    VERT_ATTRIB_COLOR0 = 3,
  151.    VERT_ATTRIB_COLOR1 = 4,
  152.    VERT_ATTRIB_FOG = 5,
  153.    VERT_ATTRIB_COLOR_INDEX = 6,
  154.    VERT_ATTRIB_POINT_SIZE = 6,  /*alias*/
  155.    VERT_ATTRIB_EDGEFLAG = 7,
  156.    VERT_ATTRIB_TEX0 = 8,
  157.    VERT_ATTRIB_TEX1 = 9,
  158.    VERT_ATTRIB_TEX2 = 10,
  159.    VERT_ATTRIB_TEX3 = 11,
  160.    VERT_ATTRIB_TEX4 = 12,
  161.    VERT_ATTRIB_TEX5 = 13,
  162.    VERT_ATTRIB_TEX6 = 14,
  163.    VERT_ATTRIB_TEX7 = 15,
  164.    VERT_ATTRIB_GENERIC0 = 16,
  165.    VERT_ATTRIB_GENERIC1 = 17,
  166.    VERT_ATTRIB_GENERIC2 = 18,
  167.    VERT_ATTRIB_GENERIC3 = 19,
  168.    VERT_ATTRIB_GENERIC4 = 20,
  169.    VERT_ATTRIB_GENERIC5 = 21,
  170.    VERT_ATTRIB_GENERIC6 = 22,
  171.    VERT_ATTRIB_GENERIC7 = 23,
  172.    VERT_ATTRIB_GENERIC8 = 24,
  173.    VERT_ATTRIB_GENERIC9 = 25,
  174.    VERT_ATTRIB_GENERIC10 = 26,
  175.    VERT_ATTRIB_GENERIC11 = 27,
  176.    VERT_ATTRIB_GENERIC12 = 28,
  177.    VERT_ATTRIB_GENERIC13 = 29,
  178.    VERT_ATTRIB_GENERIC14 = 30,
  179.    VERT_ATTRIB_GENERIC15 = 31,
  180.    VERT_ATTRIB_MAX = 32
  181. } gl_vert_attrib;
  182.  
  183. /**
  184.  * Bitflags for vertex attributes.
  185.  * These are used in bitfields in many places.
  186.  */
  187. /*@{*/
  188. #define VERT_BIT_POS         (1 << VERT_ATTRIB_POS)
  189. #define VERT_BIT_WEIGHT      (1 << VERT_ATTRIB_WEIGHT)
  190. #define VERT_BIT_NORMAL      (1 << VERT_ATTRIB_NORMAL)
  191. #define VERT_BIT_COLOR0      (1 << VERT_ATTRIB_COLOR0)
  192. #define VERT_BIT_COLOR1      (1 << VERT_ATTRIB_COLOR1)
  193. #define VERT_BIT_FOG         (1 << VERT_ATTRIB_FOG)
  194. #define VERT_BIT_COLOR_INDEX (1 << VERT_ATTRIB_COLOR_INDEX)
  195. #define VERT_BIT_EDGEFLAG    (1 << VERT_ATTRIB_EDGEFLAG)
  196. #define VERT_BIT_TEX0        (1 << VERT_ATTRIB_TEX0)
  197. #define VERT_BIT_TEX1        (1 << VERT_ATTRIB_TEX1)
  198. #define VERT_BIT_TEX2        (1 << VERT_ATTRIB_TEX2)
  199. #define VERT_BIT_TEX3        (1 << VERT_ATTRIB_TEX3)
  200. #define VERT_BIT_TEX4        (1 << VERT_ATTRIB_TEX4)
  201. #define VERT_BIT_TEX5        (1 << VERT_ATTRIB_TEX5)
  202. #define VERT_BIT_TEX6        (1 << VERT_ATTRIB_TEX6)
  203. #define VERT_BIT_TEX7        (1 << VERT_ATTRIB_TEX7)
  204. #define VERT_BIT_GENERIC0    (1 << VERT_ATTRIB_GENERIC0)
  205. #define VERT_BIT_GENERIC1    (1 << VERT_ATTRIB_GENERIC1)
  206. #define VERT_BIT_GENERIC2    (1 << VERT_ATTRIB_GENERIC2)
  207. #define VERT_BIT_GENERIC3    (1 << VERT_ATTRIB_GENERIC3)
  208. #define VERT_BIT_GENERIC4    (1 << VERT_ATTRIB_GENERIC4)
  209. #define VERT_BIT_GENERIC5    (1 << VERT_ATTRIB_GENERIC5)
  210. #define VERT_BIT_GENERIC6    (1 << VERT_ATTRIB_GENERIC6)
  211. #define VERT_BIT_GENERIC7    (1 << VERT_ATTRIB_GENERIC7)
  212. #define VERT_BIT_GENERIC8    (1 << VERT_ATTRIB_GENERIC8)
  213. #define VERT_BIT_GENERIC9    (1 << VERT_ATTRIB_GENERIC9)
  214. #define VERT_BIT_GENERIC10   (1 << VERT_ATTRIB_GENERIC10)
  215. #define VERT_BIT_GENERIC11   (1 << VERT_ATTRIB_GENERIC11)
  216. #define VERT_BIT_GENERIC12   (1 << VERT_ATTRIB_GENERIC12)
  217. #define VERT_BIT_GENERIC13   (1 << VERT_ATTRIB_GENERIC13)
  218. #define VERT_BIT_GENERIC14   (1 << VERT_ATTRIB_GENERIC14)
  219. #define VERT_BIT_GENERIC15   (1 << VERT_ATTRIB_GENERIC15)
  220.  
  221. #define VERT_BIT_TEX(u)  (1 << (VERT_ATTRIB_TEX0 + (u)))
  222. #define VERT_BIT_GENERIC(g)  (1 << (VERT_ATTRIB_GENERIC0 + (g)))
  223. /*@}*/
  224.  
  225.  
  226. /**
  227.  * Indexes for vertex program result attributes
  228.  */
  229. typedef enum
  230. {
  231.    VERT_RESULT_HPOS = 0,
  232.    VERT_RESULT_COL0 = 1,
  233.    VERT_RESULT_COL1 = 2,
  234.    VERT_RESULT_FOGC = 3,
  235.    VERT_RESULT_TEX0 = 4,
  236.    VERT_RESULT_TEX1 = 5,
  237.    VERT_RESULT_TEX2 = 6,
  238.    VERT_RESULT_TEX3 = 7,
  239.    VERT_RESULT_TEX4 = 8,
  240.    VERT_RESULT_TEX5 = 9,
  241.    VERT_RESULT_TEX6 = 10,
  242.    VERT_RESULT_TEX7 = 11,
  243.    VERT_RESULT_PSIZ = 12,
  244.    VERT_RESULT_BFC0 = 13,
  245.    VERT_RESULT_BFC1 = 14,
  246.    VERT_RESULT_EDGE = 15,
  247.    VERT_RESULT_VAR0 = 16,  /**< shader varying */
  248.    VERT_RESULT_MAX = (VERT_RESULT_VAR0 + MAX_VARYING)
  249. } gl_vert_result;
  250.  
  251.  
  252. /*********************************************/
  253.  
  254. /**
  255.  * Indexes for geometry program attributes.
  256.  */
  257. typedef enum
  258. {
  259.    GEOM_ATTRIB_POSITION = 0,
  260.    GEOM_ATTRIB_COLOR0 = 1,
  261.    GEOM_ATTRIB_COLOR1 = 2,
  262.    GEOM_ATTRIB_SECONDARY_COLOR0 = 3,
  263.    GEOM_ATTRIB_SECONDARY_COLOR1 = 4,
  264.    GEOM_ATTRIB_FOG_FRAG_COORD = 5,
  265.    GEOM_ATTRIB_POINT_SIZE = 6,
  266.    GEOM_ATTRIB_CLIP_VERTEX = 7,
  267.    GEOM_ATTRIB_PRIMITIVE_ID = 8,
  268.    GEOM_ATTRIB_TEX_COORD = 9,
  269.  
  270.    GEOM_ATTRIB_VAR0 = 16,
  271.    GEOM_ATTRIB_MAX = (GEOM_ATTRIB_VAR0 + MAX_VARYING)
  272. } gl_geom_attrib;
  273.  
  274. /**
  275.  * Bitflags for geometry attributes.
  276.  * These are used in bitfields in many places.
  277.  */
  278. /*@{*/
  279. #define GEOM_BIT_COLOR0      (1 << GEOM_ATTRIB_COLOR0)
  280. #define GEOM_BIT_COLOR1      (1 << GEOM_ATTRIB_COLOR1)
  281. #define GEOM_BIT_SCOLOR0     (1 << GEOM_ATTRIB_SECONDARY_COLOR0)
  282. #define GEOM_BIT_SCOLOR1     (1 << GEOM_ATTRIB_SECONDARY_COLOR1)
  283. #define GEOM_BIT_TEX_COORD   (1 << GEOM_ATTRIB_TEX_COORD)
  284. #define GEOM_BIT_FOG_COORD   (1 << GEOM_ATTRIB_FOG_FRAG_COORD)
  285. #define GEOM_BIT_POSITION    (1 << GEOM_ATTRIB_POSITION)
  286. #define GEOM_BIT_POINT_SIDE  (1 << GEOM_ATTRIB_POINT_SIZE)
  287. #define GEOM_BIT_CLIP_VERTEX (1 << GEOM_ATTRIB_CLIP_VERTEX)
  288. #define GEOM_BIT_PRIM_ID     (1 << GEOM_ATTRIB_PRIMITIVE_ID)
  289. #define GEOM_BIT_VAR0        (1 << GEOM_ATTRIB_VAR0)
  290.  
  291. #define GEOM_BIT_VAR(g)  (1 << (GEOM_BIT_VAR0 + (g)))
  292. /*@}*/
  293.  
  294.  
  295. /**
  296.  * Indexes for geometry program result attributes
  297.  */
  298. /*@{*/
  299. typedef enum {
  300.    GEOM_RESULT_POS  = 0,
  301.    GEOM_RESULT_COL0  = 1,
  302.    GEOM_RESULT_COL1  = 2,
  303.    GEOM_RESULT_SCOL0 = 3,
  304.    GEOM_RESULT_SCOL1 = 4,
  305.    GEOM_RESULT_FOGC = 5,
  306.    GEOM_RESULT_TEX0 = 6,
  307.    GEOM_RESULT_TEX1 = 7,
  308.    GEOM_RESULT_TEX2 = 8,
  309.    GEOM_RESULT_TEX3 = 9,
  310.    GEOM_RESULT_TEX4 = 10,
  311.    GEOM_RESULT_TEX5 = 11,
  312.    GEOM_RESULT_TEX6 = 12,
  313.    GEOM_RESULT_TEX7 = 13,
  314.    GEOM_RESULT_PSIZ = 14,
  315.    GEOM_RESULT_CLPV = 15,
  316.    GEOM_RESULT_PRID = 16,
  317.    GEOM_RESULT_LAYR = 17,
  318.    GEOM_RESULT_VAR0 = 18,  /**< shader varying, should really be 16 */
  319.    /* ### we need to -2 because var0 is 18 instead 16 like in the others */
  320.    GEOM_RESULT_MAX  =  (GEOM_RESULT_VAR0 + MAX_VARYING - 2)
  321. } gl_geom_result;
  322. /*@}*/
  323.  
  324. /**
  325.  * Indexes for fragment program input attributes.
  326.  */
  327. typedef enum
  328. {
  329.    FRAG_ATTRIB_WPOS = 0,
  330.    FRAG_ATTRIB_COL0 = 1,
  331.    FRAG_ATTRIB_COL1 = 2,
  332.    FRAG_ATTRIB_FOGC = 3,
  333.    FRAG_ATTRIB_TEX0 = 4,
  334.    FRAG_ATTRIB_TEX1 = 5,
  335.    FRAG_ATTRIB_TEX2 = 6,
  336.    FRAG_ATTRIB_TEX3 = 7,
  337.    FRAG_ATTRIB_TEX4 = 8,
  338.    FRAG_ATTRIB_TEX5 = 9,
  339.    FRAG_ATTRIB_TEX6 = 10,
  340.    FRAG_ATTRIB_TEX7 = 11,
  341.    FRAG_ATTRIB_FACE = 12,  /**< front/back face */
  342.    FRAG_ATTRIB_PNTC = 13,  /**< sprite/point coord */
  343.    FRAG_ATTRIB_VAR0 = 14,  /**< shader varying */
  344.    FRAG_ATTRIB_MAX = (FRAG_ATTRIB_VAR0 + MAX_VARYING)
  345. } gl_frag_attrib;
  346.  
  347. /**
  348.  * Bitflags for fragment program input attributes.
  349.  */
  350. /*@{*/
  351. #define FRAG_BIT_WPOS  (1 << FRAG_ATTRIB_WPOS)
  352. #define FRAG_BIT_COL0  (1 << FRAG_ATTRIB_COL0)
  353. #define FRAG_BIT_COL1  (1 << FRAG_ATTRIB_COL1)
  354. #define FRAG_BIT_FOGC  (1 << FRAG_ATTRIB_FOGC)
  355. #define FRAG_BIT_FACE  (1 << FRAG_ATTRIB_FACE)
  356. #define FRAG_BIT_PNTC  (1 << FRAG_ATTRIB_PNTC)
  357. #define FRAG_BIT_TEX0  (1 << FRAG_ATTRIB_TEX0)
  358. #define FRAG_BIT_TEX1  (1 << FRAG_ATTRIB_TEX1)
  359. #define FRAG_BIT_TEX2  (1 << FRAG_ATTRIB_TEX2)
  360. #define FRAG_BIT_TEX3  (1 << FRAG_ATTRIB_TEX3)
  361. #define FRAG_BIT_TEX4  (1 << FRAG_ATTRIB_TEX4)
  362. #define FRAG_BIT_TEX5  (1 << FRAG_ATTRIB_TEX5)
  363. #define FRAG_BIT_TEX6  (1 << FRAG_ATTRIB_TEX6)
  364. #define FRAG_BIT_TEX7  (1 << FRAG_ATTRIB_TEX7)
  365. #define FRAG_BIT_VAR0  (1 << FRAG_ATTRIB_VAR0)
  366.  
  367. #define FRAG_BIT_TEX(U)  (FRAG_BIT_TEX0 << (U))
  368. #define FRAG_BIT_VAR(V)  (FRAG_BIT_VAR0 << (V))
  369.  
  370. #define FRAG_BITS_TEX_ANY (FRAG_BIT_TEX0|       \
  371.                            FRAG_BIT_TEX1|       \
  372.                            FRAG_BIT_TEX2|       \
  373.                            FRAG_BIT_TEX3|       \
  374.                            FRAG_BIT_TEX4|       \
  375.                            FRAG_BIT_TEX5|       \
  376.                            FRAG_BIT_TEX6|       \
  377.                            FRAG_BIT_TEX7)
  378. /*@}*/
  379.  
  380.  
  381. /**
  382.  * Fragment program results
  383.  */
  384. typedef enum
  385. {
  386.    FRAG_RESULT_DEPTH = 0,
  387.    FRAG_RESULT_STENCIL = 1,
  388.    FRAG_RESULT_COLOR = 2,
  389.    FRAG_RESULT_DATA0 = 3,
  390.    FRAG_RESULT_MAX = (FRAG_RESULT_DATA0 + MAX_DRAW_BUFFERS)
  391. } gl_frag_result;
  392.  
  393.  
  394. /**
  395.  * Indexes for all renderbuffers
  396.  */
  397. typedef enum
  398. {
  399.    /* the four standard color buffers */
  400.    BUFFER_FRONT_LEFT,
  401.    BUFFER_BACK_LEFT,
  402.    BUFFER_FRONT_RIGHT,
  403.    BUFFER_BACK_RIGHT,
  404.    BUFFER_DEPTH,
  405.    BUFFER_STENCIL,
  406.    BUFFER_ACCUM,
  407.    /* optional aux buffer */
  408.    BUFFER_AUX0,
  409.    /* generic renderbuffers */
  410.    BUFFER_COLOR0,
  411.    BUFFER_COLOR1,
  412.    BUFFER_COLOR2,
  413.    BUFFER_COLOR3,
  414.    BUFFER_COLOR4,
  415.    BUFFER_COLOR5,
  416.    BUFFER_COLOR6,
  417.    BUFFER_COLOR7,
  418.    BUFFER_COUNT
  419. } gl_buffer_index;
  420.  
  421. /**
  422.  * Bit flags for all renderbuffers
  423.  */
  424. #define BUFFER_BIT_FRONT_LEFT   (1 << BUFFER_FRONT_LEFT)
  425. #define BUFFER_BIT_BACK_LEFT    (1 << BUFFER_BACK_LEFT)
  426. #define BUFFER_BIT_FRONT_RIGHT  (1 << BUFFER_FRONT_RIGHT)
  427. #define BUFFER_BIT_BACK_RIGHT   (1 << BUFFER_BACK_RIGHT)
  428. #define BUFFER_BIT_AUX0         (1 << BUFFER_AUX0)
  429. #define BUFFER_BIT_AUX1         (1 << BUFFER_AUX1)
  430. #define BUFFER_BIT_AUX2         (1 << BUFFER_AUX2)
  431. #define BUFFER_BIT_AUX3         (1 << BUFFER_AUX3)
  432. #define BUFFER_BIT_DEPTH        (1 << BUFFER_DEPTH)
  433. #define BUFFER_BIT_STENCIL      (1 << BUFFER_STENCIL)
  434. #define BUFFER_BIT_ACCUM        (1 << BUFFER_ACCUM)
  435. #define BUFFER_BIT_COLOR0       (1 << BUFFER_COLOR0)
  436. #define BUFFER_BIT_COLOR1       (1 << BUFFER_COLOR1)
  437. #define BUFFER_BIT_COLOR2       (1 << BUFFER_COLOR2)
  438. #define BUFFER_BIT_COLOR3       (1 << BUFFER_COLOR3)
  439. #define BUFFER_BIT_COLOR4       (1 << BUFFER_COLOR4)
  440. #define BUFFER_BIT_COLOR5       (1 << BUFFER_COLOR5)
  441. #define BUFFER_BIT_COLOR6       (1 << BUFFER_COLOR6)
  442. #define BUFFER_BIT_COLOR7       (1 << BUFFER_COLOR7)
  443.  
  444. /**
  445.  * Mask of all the color buffer bits (but not accum).
  446.  */
  447. #define BUFFER_BITS_COLOR  (BUFFER_BIT_FRONT_LEFT | \
  448.                             BUFFER_BIT_BACK_LEFT | \
  449.                             BUFFER_BIT_FRONT_RIGHT | \
  450.                             BUFFER_BIT_BACK_RIGHT | \
  451.                             BUFFER_BIT_AUX0 | \
  452.                             BUFFER_BIT_COLOR0 | \
  453.                             BUFFER_BIT_COLOR1 | \
  454.                             BUFFER_BIT_COLOR2 | \
  455.                             BUFFER_BIT_COLOR3 | \
  456.                             BUFFER_BIT_COLOR4 | \
  457.                             BUFFER_BIT_COLOR5 | \
  458.                             BUFFER_BIT_COLOR6 | \
  459.                             BUFFER_BIT_COLOR7)
  460.  
  461.  
  462. /**
  463.  * Framebuffer configuration (aka visual / pixelformat)
  464.  * Note: some of these fields should be boolean, but it appears that
  465.  * code in drivers/dri/common/util.c requires int-sized fields.
  466.  */
  467. struct gl_config
  468. {
  469.    GLboolean rgbMode;
  470.    GLboolean floatMode;
  471.    GLboolean colorIndexMode;  /* XXX is this used anywhere? */
  472.    GLuint doubleBufferMode;
  473.    GLuint stereoMode;
  474.  
  475.    GLboolean haveAccumBuffer;
  476.    GLboolean haveDepthBuffer;
  477.    GLboolean haveStencilBuffer;
  478.  
  479.    GLint redBits, greenBits, blueBits, alphaBits;       /* bits per comp */
  480.    GLuint redMask, greenMask, blueMask, alphaMask;
  481.    GLint rgbBits;               /* total bits for rgb */
  482.    GLint indexBits;             /* total bits for colorindex */
  483.  
  484.    GLint accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits;
  485.    GLint depthBits;
  486.    GLint stencilBits;
  487.  
  488.    GLint numAuxBuffers;
  489.  
  490.    GLint level;
  491.  
  492.    /* EXT_visual_rating / GLX 1.2 */
  493.    GLint visualRating;
  494.  
  495.    /* EXT_visual_info / GLX 1.2 */
  496.    GLint transparentPixel;
  497.    /*    colors are floats scaled to ints */
  498.    GLint transparentRed, transparentGreen, transparentBlue, transparentAlpha;
  499.    GLint transparentIndex;
  500.  
  501.    /* ARB_multisample / SGIS_multisample */
  502.    GLint sampleBuffers;
  503.    GLint samples;
  504.  
  505.    /* SGIX_pbuffer / GLX 1.3 */
  506.    GLint maxPbufferWidth;
  507.    GLint maxPbufferHeight;
  508.    GLint maxPbufferPixels;
  509.    GLint optimalPbufferWidth;   /* Only for SGIX_pbuffer. */
  510.    GLint optimalPbufferHeight;  /* Only for SGIX_pbuffer. */
  511.  
  512.    /* OML_swap_method */
  513.    GLint swapMethod;
  514.  
  515.    /* EXT_texture_from_pixmap */
  516.    GLint bindToTextureRgb;
  517.    GLint bindToTextureRgba;
  518.    GLint bindToMipmapTexture;
  519.    GLint bindToTextureTargets;
  520.    GLint yInverted;
  521. };
  522.  
  523.  
  524. /**
  525.  * Data structure for color tables
  526.  */
  527. struct gl_color_table
  528. {
  529.    GLenum InternalFormat;      /**< The user-specified format */
  530.    GLenum _BaseFormat;         /**< GL_ALPHA, GL_RGBA, GL_RGB, etc */
  531.    GLuint Size;                /**< number of entries in table */
  532.    GLfloat *TableF;            /**< Color table, floating point values */
  533.    GLubyte *TableUB;           /**< Color table, ubyte values */
  534.    GLubyte RedSize;
  535.    GLubyte GreenSize;
  536.    GLubyte BlueSize;
  537.    GLubyte AlphaSize;
  538.    GLubyte LuminanceSize;
  539.    GLubyte IntensitySize;
  540. };
  541.  
  542.  
  543. /**
  544.  * \name Bit flags used for updating material values.
  545.  */
  546. /*@{*/
  547. #define MAT_ATTRIB_FRONT_AMBIENT           0
  548. #define MAT_ATTRIB_BACK_AMBIENT            1
  549. #define MAT_ATTRIB_FRONT_DIFFUSE           2
  550. #define MAT_ATTRIB_BACK_DIFFUSE            3
  551. #define MAT_ATTRIB_FRONT_SPECULAR          4
  552. #define MAT_ATTRIB_BACK_SPECULAR           5
  553. #define MAT_ATTRIB_FRONT_EMISSION          6
  554. #define MAT_ATTRIB_BACK_EMISSION           7
  555. #define MAT_ATTRIB_FRONT_SHININESS         8
  556. #define MAT_ATTRIB_BACK_SHININESS          9
  557. #define MAT_ATTRIB_FRONT_INDEXES           10
  558. #define MAT_ATTRIB_BACK_INDEXES            11
  559. #define MAT_ATTRIB_MAX                     12
  560.  
  561. #define MAT_ATTRIB_AMBIENT(f)  (MAT_ATTRIB_FRONT_AMBIENT+(f))
  562. #define MAT_ATTRIB_DIFFUSE(f)  (MAT_ATTRIB_FRONT_DIFFUSE+(f))
  563. #define MAT_ATTRIB_SPECULAR(f) (MAT_ATTRIB_FRONT_SPECULAR+(f))
  564. #define MAT_ATTRIB_EMISSION(f) (MAT_ATTRIB_FRONT_EMISSION+(f))
  565. #define MAT_ATTRIB_SHININESS(f)(MAT_ATTRIB_FRONT_SHININESS+(f))
  566. #define MAT_ATTRIB_INDEXES(f)  (MAT_ATTRIB_FRONT_INDEXES+(f))
  567.  
  568. #define MAT_INDEX_AMBIENT  0
  569. #define MAT_INDEX_DIFFUSE  1
  570. #define MAT_INDEX_SPECULAR 2
  571.  
  572. #define MAT_BIT_FRONT_AMBIENT         (1<<MAT_ATTRIB_FRONT_AMBIENT)
  573. #define MAT_BIT_BACK_AMBIENT          (1<<MAT_ATTRIB_BACK_AMBIENT)
  574. #define MAT_BIT_FRONT_DIFFUSE         (1<<MAT_ATTRIB_FRONT_DIFFUSE)
  575. #define MAT_BIT_BACK_DIFFUSE          (1<<MAT_ATTRIB_BACK_DIFFUSE)
  576. #define MAT_BIT_FRONT_SPECULAR        (1<<MAT_ATTRIB_FRONT_SPECULAR)
  577. #define MAT_BIT_BACK_SPECULAR         (1<<MAT_ATTRIB_BACK_SPECULAR)
  578. #define MAT_BIT_FRONT_EMISSION        (1<<MAT_ATTRIB_FRONT_EMISSION)
  579. #define MAT_BIT_BACK_EMISSION         (1<<MAT_ATTRIB_BACK_EMISSION)
  580. #define MAT_BIT_FRONT_SHININESS       (1<<MAT_ATTRIB_FRONT_SHININESS)
  581. #define MAT_BIT_BACK_SHININESS        (1<<MAT_ATTRIB_BACK_SHININESS)
  582. #define MAT_BIT_FRONT_INDEXES         (1<<MAT_ATTRIB_FRONT_INDEXES)
  583. #define MAT_BIT_BACK_INDEXES          (1<<MAT_ATTRIB_BACK_INDEXES)
  584.  
  585.  
  586. #define FRONT_MATERIAL_BITS     (MAT_BIT_FRONT_EMISSION |       \
  587.                                  MAT_BIT_FRONT_AMBIENT |        \
  588.                                  MAT_BIT_FRONT_DIFFUSE |        \
  589.                                  MAT_BIT_FRONT_SPECULAR |       \
  590.                                  MAT_BIT_FRONT_SHININESS |      \
  591.                                  MAT_BIT_FRONT_INDEXES)
  592.  
  593. #define BACK_MATERIAL_BITS      (MAT_BIT_BACK_EMISSION |        \
  594.                                  MAT_BIT_BACK_AMBIENT |         \
  595.                                  MAT_BIT_BACK_DIFFUSE |         \
  596.                                  MAT_BIT_BACK_SPECULAR |        \
  597.                                  MAT_BIT_BACK_SHININESS |       \
  598.                                  MAT_BIT_BACK_INDEXES)
  599.  
  600. #define ALL_MATERIAL_BITS       (FRONT_MATERIAL_BITS | BACK_MATERIAL_BITS)
  601. /*@}*/
  602.  
  603.  
  604. #define EXP_TABLE_SIZE 512      /**< Specular exponent lookup table sizes */
  605. #define SHINE_TABLE_SIZE 256    /**< Material shininess lookup table sizes */
  606.  
  607. /**
  608.  * Material shininess lookup table.
  609.  */
  610. struct gl_shine_tab
  611. {
  612.    struct gl_shine_tab *next, *prev;
  613.    GLfloat tab[SHINE_TABLE_SIZE+1];
  614.    GLfloat shininess;
  615.    GLuint refcount;
  616. };
  617.  
  618.  
  619. /**
  620.  * Light source state.
  621.  */
  622. struct gl_light
  623. {
  624.    struct gl_light *next;       /**< double linked list with sentinel */
  625.    struct gl_light *prev;
  626.  
  627.    GLfloat Ambient[4];          /**< ambient color */
  628.    GLfloat Diffuse[4];          /**< diffuse color */
  629.    GLfloat Specular[4];         /**< specular color */
  630.    GLfloat EyePosition[4];      /**< position in eye coordinates */
  631.    GLfloat SpotDirection[4];    /**< spotlight direction in eye coordinates */
  632.    GLfloat SpotExponent;
  633.    GLfloat SpotCutoff;          /**< in degrees */
  634.    GLfloat _CosCutoffNeg;       /**< = cos(SpotCutoff) */
  635.    GLfloat _CosCutoff;          /**< = MAX(0, cos(SpotCutoff)) */
  636.    GLfloat ConstantAttenuation;
  637.    GLfloat LinearAttenuation;
  638.    GLfloat QuadraticAttenuation;
  639.    GLboolean Enabled;           /**< On/off flag */
  640.  
  641.    /**
  642.     * \name Derived fields
  643.     */
  644.    /*@{*/
  645.    GLbitfield _Flags;           /**< State */
  646.  
  647.    GLfloat _Position[4];        /**< position in eye/obj coordinates */
  648.    GLfloat _VP_inf_norm[3];     /**< Norm direction to infinite light */
  649.    GLfloat _h_inf_norm[3];      /**< Norm( _VP_inf_norm + <0,0,1> ) */
  650.    GLfloat _NormSpotDirection[4]; /**< normalized spotlight direction */
  651.    GLfloat _VP_inf_spot_attenuation;
  652.  
  653.    GLfloat _SpotExpTable[EXP_TABLE_SIZE][2];  /**< to replace a pow() call */
  654.    GLfloat _MatAmbient[2][3];   /**< material ambient * light ambient */
  655.    GLfloat _MatDiffuse[2][3];   /**< material diffuse * light diffuse */
  656.    GLfloat _MatSpecular[2][3];  /**< material spec * light specular */
  657.    GLfloat _dli;                /**< CI diffuse light intensity */
  658.    GLfloat _sli;                /**< CI specular light intensity */
  659.    /*@}*/
  660. };
  661.  
  662.  
  663. /**
  664.  * Light model state.
  665.  */
  666. struct gl_lightmodel
  667. {
  668.    GLfloat Ambient[4];          /**< ambient color */
  669.    GLboolean LocalViewer;       /**< Local (or infinite) view point? */
  670.    GLboolean TwoSide;           /**< Two (or one) sided lighting? */
  671.    GLenum ColorControl;         /**< either GL_SINGLE_COLOR
  672.                                  *    or GL_SEPARATE_SPECULAR_COLOR */
  673. };
  674.  
  675.  
  676. /**
  677.  * Material state.
  678.  */
  679. struct gl_material
  680. {
  681.    GLfloat Attrib[MAT_ATTRIB_MAX][4];
  682. };
  683.  
  684.  
  685. /**
  686.  * Accumulation buffer attribute group (GL_ACCUM_BUFFER_BIT)
  687.  */
  688. struct gl_accum_attrib
  689. {
  690.    GLfloat ClearColor[4];       /**< Accumulation buffer clear color */
  691. };
  692.  
  693.  
  694. /**
  695.  * Color buffer attribute group (GL_COLOR_BUFFER_BIT).
  696.  */
  697. struct gl_colorbuffer_attrib
  698. {
  699.    GLuint ClearIndex;                   /**< Index to use for glClear */
  700.    GLclampf ClearColor[4];              /**< Color to use for glClear */
  701.  
  702.    GLuint IndexMask;                    /**< Color index write mask */
  703.    GLubyte ColorMask[MAX_DRAW_BUFFERS][4];/**< Each flag is 0xff or 0x0 */
  704.  
  705.    GLenum DrawBuffer[MAX_DRAW_BUFFERS]; /**< Which buffer to draw into */
  706.  
  707.    /**
  708.     * \name alpha testing
  709.     */
  710.    /*@{*/
  711.    GLboolean AlphaEnabled;              /**< Alpha test enabled flag */
  712.    GLenum AlphaFunc;                    /**< Alpha test function */
  713.    GLclampf AlphaRef;                   /**< Alpha reference value */
  714.    /*@}*/
  715.  
  716.    /**
  717.     * \name Blending
  718.     */
  719.    /*@{*/
  720.    GLbitfield BlendEnabled;             /**< Per-buffer blend enable flags */
  721.    GLenum BlendSrcRGB;                  /**< Blending source operator */
  722.    GLenum BlendDstRGB;                  /**< Blending destination operator */
  723.    GLenum BlendSrcA;                    /**< GL_INGR_blend_func_separate */
  724.    GLenum BlendDstA;                    /**< GL_INGR_blend_func_separate */
  725.    GLenum BlendEquationRGB;             /**< Blending equation */
  726.    GLenum BlendEquationA;               /**< GL_EXT_blend_equation_separate */
  727.    GLfloat BlendColor[4];               /**< Blending color */
  728.    /*@}*/
  729.  
  730.    /**
  731.     * \name Logic op
  732.     */
  733.    /*@{*/
  734.    GLenum LogicOp;                      /**< Logic operator */
  735.    GLboolean IndexLogicOpEnabled;       /**< Color index logic op enabled flag */
  736.    GLboolean ColorLogicOpEnabled;       /**< RGBA logic op enabled flag */
  737.    GLboolean _LogicOpEnabled;           /**< RGBA logic op + EXT_blend_logic_op enabled flag */
  738.    /*@}*/
  739.  
  740.    GLboolean DitherFlag;                /**< Dither enable flag */
  741.  
  742.    GLenum ClampFragmentColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
  743.    GLenum ClampReadColor;     /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
  744. };
  745.  
  746.  
  747. /**
  748.  * Current attribute group (GL_CURRENT_BIT).
  749.  */
  750. struct gl_current_attrib
  751. {
  752.    /**
  753.     * \name Current vertex attributes.
  754.     * \note Values are valid only after FLUSH_VERTICES has been called.
  755.     * \note Index and Edgeflag current values are stored as floats in the
  756.     * SIX and SEVEN attribute slots.
  757.     */
  758.    GLfloat Attrib[VERT_ATTRIB_MAX][4];  /**< Position, color, texcoords, etc */
  759.  
  760.    /**
  761.     * \name Current raster position attributes (always valid).
  762.     * \note This set of attributes is very similar to the SWvertex struct.
  763.     */
  764.    /*@{*/
  765.    GLfloat RasterPos[4];
  766.    GLfloat RasterDistance;
  767.    GLfloat RasterColor[4];
  768.    GLfloat RasterSecondaryColor[4];
  769.    GLfloat RasterTexCoords[MAX_TEXTURE_COORD_UNITS][4];
  770.    GLboolean RasterPosValid;
  771.    /*@}*/
  772. };
  773.  
  774.  
  775. /**
  776.  * Depth buffer attribute group (GL_DEPTH_BUFFER_BIT).
  777.  */
  778. struct gl_depthbuffer_attrib
  779. {
  780.    GLenum Func;                 /**< Function for depth buffer compare */
  781.    GLclampd Clear;              /**< Value to clear depth buffer to */
  782.    GLboolean Test;              /**< Depth buffering enabled flag */
  783.    GLboolean Mask;              /**< Depth buffer writable? */
  784.    GLboolean BoundsTest;        /**< GL_EXT_depth_bounds_test */
  785.    GLfloat BoundsMin, BoundsMax;/**< GL_EXT_depth_bounds_test */
  786. };
  787.  
  788.  
  789. /**
  790.  * Evaluator attribute group (GL_EVAL_BIT).
  791.  */
  792. struct gl_eval_attrib
  793. {
  794.    /**
  795.     * \name Enable bits
  796.     */
  797.    /*@{*/
  798.    GLboolean Map1Color4;
  799.    GLboolean Map1Index;
  800.    GLboolean Map1Normal;
  801.    GLboolean Map1TextureCoord1;
  802.    GLboolean Map1TextureCoord2;
  803.    GLboolean Map1TextureCoord3;
  804.    GLboolean Map1TextureCoord4;
  805.    GLboolean Map1Vertex3;
  806.    GLboolean Map1Vertex4;
  807.    GLboolean Map1Attrib[16];  /* GL_NV_vertex_program */
  808.    GLboolean Map2Color4;
  809.    GLboolean Map2Index;
  810.    GLboolean Map2Normal;
  811.    GLboolean Map2TextureCoord1;
  812.    GLboolean Map2TextureCoord2;
  813.    GLboolean Map2TextureCoord3;
  814.    GLboolean Map2TextureCoord4;
  815.    GLboolean Map2Vertex3;
  816.    GLboolean Map2Vertex4;
  817.    GLboolean Map2Attrib[16];  /* GL_NV_vertex_program */
  818.    GLboolean AutoNormal;
  819.    /*@}*/
  820.  
  821.    /**
  822.     * \name Map Grid endpoints and divisions and calculated du values
  823.     */
  824.    /*@{*/
  825.    GLint MapGrid1un;
  826.    GLfloat MapGrid1u1, MapGrid1u2, MapGrid1du;
  827.    GLint MapGrid2un, MapGrid2vn;
  828.    GLfloat MapGrid2u1, MapGrid2u2, MapGrid2du;
  829.    GLfloat MapGrid2v1, MapGrid2v2, MapGrid2dv;
  830.    /*@}*/
  831. };
  832.  
  833.  
  834. /**
  835.  * Fog attribute group (GL_FOG_BIT).
  836.  */
  837. struct gl_fog_attrib
  838. {
  839.    GLboolean Enabled;           /**< Fog enabled flag */
  840.    GLfloat Color[4];            /**< Fog color */
  841.    GLfloat Density;             /**< Density >= 0.0 */
  842.    GLfloat Start;               /**< Start distance in eye coords */
  843.    GLfloat End;                 /**< End distance in eye coords */
  844.    GLfloat Index;               /**< Fog index */
  845.    GLenum Mode;                 /**< Fog mode */
  846.    GLboolean ColorSumEnabled;
  847.    GLenum FogCoordinateSource;  /**< GL_EXT_fog_coord */
  848.    GLfloat _Scale;              /**< (End == Start) ? 1.0 : 1.0 / (End - Start) */
  849. };
  850.  
  851.  
  852. /**
  853.  * Hint attribute group (GL_HINT_BIT).
  854.  *
  855.  * Values are always one of GL_FASTEST, GL_NICEST, or GL_DONT_CARE.
  856.  */
  857. struct gl_hint_attrib
  858. {
  859.    GLenum PerspectiveCorrection;
  860.    GLenum PointSmooth;
  861.    GLenum LineSmooth;
  862.    GLenum PolygonSmooth;
  863.    GLenum Fog;
  864.    GLenum ClipVolumeClipping;   /**< GL_EXT_clip_volume_hint */
  865.    GLenum TextureCompression;   /**< GL_ARB_texture_compression */
  866.    GLenum GenerateMipmap;       /**< GL_SGIS_generate_mipmap */
  867.    GLenum FragmentShaderDerivative; /**< GL_ARB_fragment_shader */
  868. };
  869.  
  870. /**
  871.  * Light state flags.
  872.  */
  873. /*@{*/
  874. #define LIGHT_SPOT         0x1
  875. #define LIGHT_LOCAL_VIEWER 0x2
  876. #define LIGHT_POSITIONAL   0x4
  877. #define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER)
  878. /*@}*/
  879.  
  880.  
  881. /**
  882.  * Lighting attribute group (GL_LIGHT_BIT).
  883.  */
  884. struct gl_light_attrib
  885. {
  886.    struct gl_light Light[MAX_LIGHTS];   /**< Array of light sources */
  887.    struct gl_lightmodel Model;          /**< Lighting model */
  888.  
  889.    /**
  890.     * Must flush FLUSH_VERTICES before referencing:
  891.     */
  892.    /*@{*/
  893.    struct gl_material Material;         /**< Includes front & back values */
  894.    /*@}*/
  895.  
  896.    GLboolean Enabled;                   /**< Lighting enabled flag */
  897.    GLenum ShadeModel;                   /**< GL_FLAT or GL_SMOOTH */
  898.    GLenum ProvokingVertex;              /**< GL_EXT_provoking_vertex */
  899.    GLenum ColorMaterialFace;            /**< GL_FRONT, BACK or FRONT_AND_BACK */
  900.    GLenum ColorMaterialMode;            /**< GL_AMBIENT, GL_DIFFUSE, etc */
  901.    GLbitfield ColorMaterialBitmask;     /**< bitmask formed from Face and Mode */
  902.    GLboolean ColorMaterialEnabled;
  903.    GLenum ClampVertexColor;
  904.  
  905.    struct gl_light EnabledList;         /**< List sentinel */
  906.  
  907.    /**
  908.     * Derived state for optimizations:
  909.     */
  910.    /*@{*/
  911.    GLboolean _NeedEyeCoords;
  912.    GLboolean _NeedVertices;             /**< Use fast shader? */
  913.    GLbitfield _Flags;                   /**< LIGHT_* flags, see above */
  914.    GLfloat _BaseColor[2][3];
  915.    /*@}*/
  916. };
  917.  
  918.  
  919. /**
  920.  * Line attribute group (GL_LINE_BIT).
  921.  */
  922. struct gl_line_attrib
  923. {
  924.    GLboolean SmoothFlag;        /**< GL_LINE_SMOOTH enabled? */
  925.    GLboolean StippleFlag;       /**< GL_LINE_STIPPLE enabled? */
  926.    GLushort StipplePattern;     /**< Stipple pattern */
  927.    GLint StippleFactor;         /**< Stipple repeat factor */
  928.    GLfloat Width;               /**< Line width */
  929. };
  930.  
  931.  
  932. /**
  933.  * Display list attribute group (GL_LIST_BIT).
  934.  */
  935. struct gl_list_attrib
  936. {
  937.    GLuint ListBase;
  938. };
  939.  
  940.  
  941. /**
  942.  * Multisample attribute group (GL_MULTISAMPLE_BIT).
  943.  */
  944. struct gl_multisample_attrib
  945. {
  946.    GLboolean Enabled;
  947.    GLboolean _Enabled;   /**< true if Enabled and multisample buffer */
  948.    GLboolean SampleAlphaToCoverage;
  949.    GLboolean SampleAlphaToOne;
  950.    GLboolean SampleCoverage;
  951.    GLfloat SampleCoverageValue;
  952.    GLboolean SampleCoverageInvert;
  953. };
  954.  
  955.  
  956. /**
  957.  * A pixelmap (see glPixelMap)
  958.  */
  959. struct gl_pixelmap
  960. {
  961.    GLint Size;
  962.    GLfloat Map[MAX_PIXEL_MAP_TABLE];
  963.    GLubyte Map8[MAX_PIXEL_MAP_TABLE];  /**< converted to 8-bit color */
  964. };
  965.  
  966.  
  967. /**
  968.  * Collection of all pixelmaps
  969.  */
  970. struct gl_pixelmaps
  971. {
  972.    struct gl_pixelmap RtoR;  /**< i.e. GL_PIXEL_MAP_R_TO_R */
  973.    struct gl_pixelmap GtoG;
  974.    struct gl_pixelmap BtoB;
  975.    struct gl_pixelmap AtoA;
  976.    struct gl_pixelmap ItoR;
  977.    struct gl_pixelmap ItoG;
  978.    struct gl_pixelmap ItoB;
  979.    struct gl_pixelmap ItoA;
  980.    struct gl_pixelmap ItoI;
  981.    struct gl_pixelmap StoS;
  982. };
  983.  
  984.  
  985. /**
  986.  * Pixel attribute group (GL_PIXEL_MODE_BIT).
  987.  */
  988. struct gl_pixel_attrib
  989. {
  990.    GLenum ReadBuffer;           /**< source buffer for glRead/CopyPixels() */
  991.  
  992.    /*--- Begin Pixel Transfer State ---*/
  993.    /* Fields are in the order in which they're applied... */
  994.  
  995.    /** Scale & Bias (index shift, offset) */
  996.    /*@{*/
  997.    GLfloat RedBias, RedScale;
  998.    GLfloat GreenBias, GreenScale;
  999.    GLfloat BlueBias, BlueScale;
  1000.    GLfloat AlphaBias, AlphaScale;
  1001.    GLfloat DepthBias, DepthScale;
  1002.    GLint IndexShift, IndexOffset;
  1003.    /*@}*/
  1004.  
  1005.    /* Pixel Maps */
  1006.    /* Note: actual pixel maps are not part of this attrib group */
  1007.    GLboolean MapColorFlag;
  1008.    GLboolean MapStencilFlag;
  1009.  
  1010.    /*--- End Pixel Transfer State ---*/
  1011.  
  1012.    /** glPixelZoom */
  1013.    GLfloat ZoomX, ZoomY;
  1014.  
  1015.    /** GL_SGI_texture_color_table */
  1016.    GLfloat TextureColorTableScale[4]; /**< RGBA */
  1017.    GLfloat TextureColorTableBias[4];  /**< RGBA */
  1018. };
  1019.  
  1020.  
  1021. /**
  1022.  * Point attribute group (GL_POINT_BIT).
  1023.  */
  1024. struct gl_point_attrib
  1025. {
  1026.    GLboolean SmoothFlag;        /**< True if GL_POINT_SMOOTH is enabled */
  1027.    GLfloat Size;                /**< User-specified point size */
  1028.    GLfloat Params[3];           /**< GL_EXT_point_parameters */
  1029.    GLfloat MinSize, MaxSize;    /**< GL_EXT_point_parameters */
  1030.    GLfloat Threshold;           /**< GL_EXT_point_parameters */
  1031.    GLboolean _Attenuated;       /**< True if Params != [1, 0, 0] */
  1032.    GLboolean PointSprite;       /**< GL_NV/ARB_point_sprite */
  1033.    GLboolean CoordReplace[MAX_TEXTURE_COORD_UNITS]; /**< GL_ARB_point_sprite*/
  1034.    GLenum SpriteRMode;          /**< GL_NV_point_sprite (only!) */
  1035.    GLenum SpriteOrigin;         /**< GL_ARB_point_sprite */
  1036. };
  1037.  
  1038.  
  1039. /**
  1040.  * Polygon attribute group (GL_POLYGON_BIT).
  1041.  */
  1042. struct gl_polygon_attrib
  1043. {
  1044.    GLenum FrontFace;            /**< Either GL_CW or GL_CCW */
  1045.    GLenum FrontMode;            /**< Either GL_POINT, GL_LINE or GL_FILL */
  1046.    GLenum BackMode;             /**< Either GL_POINT, GL_LINE or GL_FILL */
  1047.    GLboolean _FrontBit;         /**< 0=GL_CCW, 1=GL_CW */
  1048.    GLboolean CullFlag;          /**< Culling on/off flag */
  1049.    GLboolean SmoothFlag;        /**< True if GL_POLYGON_SMOOTH is enabled */
  1050.    GLboolean StippleFlag;       /**< True if GL_POLYGON_STIPPLE is enabled */
  1051.    GLenum CullFaceMode;         /**< Culling mode GL_FRONT or GL_BACK */
  1052.    GLfloat OffsetFactor;        /**< Polygon offset factor, from user */
  1053.    GLfloat OffsetUnits;         /**< Polygon offset units, from user */
  1054.    GLboolean OffsetPoint;       /**< Offset in GL_POINT mode */
  1055.    GLboolean OffsetLine;        /**< Offset in GL_LINE mode */
  1056.    GLboolean OffsetFill;        /**< Offset in GL_FILL mode */
  1057. };
  1058.  
  1059.  
  1060. /**
  1061.  * Scissor attributes (GL_SCISSOR_BIT).
  1062.  */
  1063. struct gl_scissor_attrib
  1064. {
  1065.    GLboolean Enabled;           /**< Scissor test enabled? */
  1066.    GLint X, Y;                  /**< Lower left corner of box */
  1067.    GLsizei Width, Height;       /**< Size of box */
  1068. };
  1069.  
  1070.  
  1071. /**
  1072.  * Stencil attribute group (GL_STENCIL_BUFFER_BIT).
  1073.  *
  1074.  * Three sets of stencil data are tracked so that OpenGL 2.0,
  1075.  * GL_EXT_stencil_two_side, and GL_ATI_separate_stencil can all be supported
  1076.  * simultaneously.  In each of the stencil state arrays, element 0 corresponds
  1077.  * to GL_FRONT.  Element 1 corresponds to the OpenGL 2.0 /
  1078.  * GL_ATI_separate_stencil GL_BACK state.  Element 2 corresponds to the
  1079.  * GL_EXT_stencil_two_side GL_BACK state.
  1080.  *
  1081.  * The derived value \c _BackFace is either 1 or 2 depending on whether or
  1082.  * not GL_STENCIL_TEST_TWO_SIDE_EXT is enabled.
  1083.  *
  1084.  * The derived value \c _TestTwoSide is set when the front-face and back-face
  1085.  * stencil state are different.
  1086.  */
  1087. struct gl_stencil_attrib
  1088. {
  1089.    GLboolean Enabled;           /**< Enabled flag */
  1090.    GLboolean TestTwoSide;       /**< GL_EXT_stencil_two_side */
  1091.    GLubyte ActiveFace;          /**< GL_EXT_stencil_two_side (0 or 2) */
  1092.    GLboolean _Enabled;          /**< Enabled and stencil buffer present */
  1093.    GLboolean _TestTwoSide;
  1094.    GLubyte _BackFace;           /**< Current back stencil state (1 or 2) */
  1095.    GLenum Function[3];          /**< Stencil function */
  1096.    GLenum FailFunc[3];          /**< Fail function */
  1097.    GLenum ZPassFunc[3];         /**< Depth buffer pass function */
  1098.    GLenum ZFailFunc[3];         /**< Depth buffer fail function */
  1099.    GLint Ref[3];                /**< Reference value */
  1100.    GLuint ValueMask[3];         /**< Value mask */
  1101.    GLuint WriteMask[3];         /**< Write mask */
  1102.    GLuint Clear;                /**< Clear value */
  1103. };
  1104.  
  1105.  
  1106. /**
  1107.  * An index for each type of texture object.  These correspond to the GL
  1108.  * texture target enums, such as GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP, etc.
  1109.  * Note: the order is from highest priority to lowest priority.
  1110.  */
  1111. typedef enum
  1112. {
  1113.    TEXTURE_2D_ARRAY_INDEX,
  1114.    TEXTURE_1D_ARRAY_INDEX,
  1115.    TEXTURE_CUBE_INDEX,
  1116.    TEXTURE_3D_INDEX,
  1117.    TEXTURE_RECT_INDEX,
  1118.    TEXTURE_2D_INDEX,
  1119.    TEXTURE_1D_INDEX,
  1120.    NUM_TEXTURE_TARGETS
  1121. } gl_texture_index;
  1122.  
  1123.  
  1124. /**
  1125.  * Bit flags for each type of texture object
  1126.  * Used for Texture.Unit[]._ReallyEnabled flags.
  1127.  */
  1128. /*@{*/
  1129. #define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX)
  1130. #define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX)
  1131. #define TEXTURE_CUBE_BIT     (1 << TEXTURE_CUBE_INDEX)
  1132. #define TEXTURE_3D_BIT       (1 << TEXTURE_3D_INDEX)
  1133. #define TEXTURE_RECT_BIT     (1 << TEXTURE_RECT_INDEX)
  1134. #define TEXTURE_2D_BIT       (1 << TEXTURE_2D_INDEX)
  1135. #define TEXTURE_1D_BIT       (1 << TEXTURE_1D_INDEX)
  1136. /*@}*/
  1137.  
  1138.  
  1139. /**
  1140.  * TexGenEnabled flags.
  1141.  */
  1142. /*@{*/
  1143. #define S_BIT 1
  1144. #define T_BIT 2
  1145. #define R_BIT 4
  1146. #define Q_BIT 8
  1147. #define STR_BITS (S_BIT | T_BIT | R_BIT)
  1148. /*@}*/
  1149.  
  1150.  
  1151. /**
  1152.  * Bit flag versions of the corresponding GL_ constants.
  1153.  */
  1154. /*@{*/
  1155. #define TEXGEN_SPHERE_MAP        0x1
  1156. #define TEXGEN_OBJ_LINEAR        0x2
  1157. #define TEXGEN_EYE_LINEAR        0x4
  1158. #define TEXGEN_REFLECTION_MAP_NV 0x8
  1159. #define TEXGEN_NORMAL_MAP_NV     0x10
  1160.  
  1161. #define TEXGEN_NEED_NORMALS      (TEXGEN_SPHERE_MAP        | \
  1162.                                   TEXGEN_REFLECTION_MAP_NV | \
  1163.                                   TEXGEN_NORMAL_MAP_NV)
  1164. #define TEXGEN_NEED_EYE_COORD    (TEXGEN_SPHERE_MAP        | \
  1165.                                   TEXGEN_REFLECTION_MAP_NV | \
  1166.                                   TEXGEN_NORMAL_MAP_NV     | \
  1167.                                   TEXGEN_EYE_LINEAR)
  1168. /*@}*/
  1169.  
  1170.  
  1171.  
  1172. /** Tex-gen enabled for texture unit? */
  1173. #define ENABLE_TEXGEN(unit) (1 << (unit))
  1174.  
  1175. /** Non-identity texture matrix for texture unit? */
  1176. #define ENABLE_TEXMAT(unit) (1 << (unit))
  1177.  
  1178.  
  1179. /**
  1180.  * Texel fetch function prototype.  We use texel fetch functions to
  1181.  * extract RGBA, color indexes and depth components out of 1D, 2D and 3D
  1182.  * texture images.  These functions help to isolate us from the gritty
  1183.  * details of all the various texture image encodings.
  1184.  *
  1185.  * \param texImage texture image.
  1186.  * \param col texel column.
  1187.  * \param row texel row.
  1188.  * \param img texel image level/layer.
  1189.  * \param texelOut output texel (up to 4 GLchans)
  1190.  */
  1191. typedef void (*FetchTexelFuncC)( const struct gl_texture_image *texImage,
  1192.                                  GLint col, GLint row, GLint img,
  1193.                                  GLchan *texelOut );
  1194.  
  1195. /**
  1196.  * As above, but returns floats.
  1197.  * Used for depth component images and for upcoming signed/float
  1198.  * texture images.
  1199.  */
  1200. typedef void (*FetchTexelFuncF)( const struct gl_texture_image *texImage,
  1201.                                  GLint col, GLint row, GLint img,
  1202.                                  GLfloat *texelOut );
  1203.  
  1204.  
  1205. typedef void (*StoreTexelFunc)(struct gl_texture_image *texImage,
  1206.                                GLint col, GLint row, GLint img,
  1207.                                const void *texel);
  1208.  
  1209.  
  1210. /**
  1211.  * Texture image state.  Describes the dimensions of a texture image,
  1212.  * the texel format and pointers to Texel Fetch functions.
  1213.  */
  1214. struct gl_texture_image
  1215. {
  1216.    GLint InternalFormat;        /**< Internal format as given by the user */
  1217.    GLenum _BaseFormat;          /**< Either GL_RGB, GL_RGBA, GL_ALPHA,
  1218.                                  *   GL_LUMINANCE, GL_LUMINANCE_ALPHA,
  1219.                                  *   GL_INTENSITY, GL_COLOR_INDEX,
  1220.                                  *   GL_DEPTH_COMPONENT or GL_DEPTH_STENCIL_EXT
  1221.                                  *   only. Used for choosing TexEnv arithmetic.
  1222.                                  */
  1223.    GLuint TexFormat;            /**< The actual format: MESA_FORMAT_x */
  1224.  
  1225.    GLuint Border;               /**< 0 or 1 */
  1226.    GLuint Width;                /**< = 2^WidthLog2 + 2*Border */
  1227.    GLuint Height;               /**< = 2^HeightLog2 + 2*Border */
  1228.    GLuint Depth;                /**< = 2^DepthLog2 + 2*Border */
  1229.    GLuint Width2;               /**< = Width - 2*Border */
  1230.    GLuint Height2;              /**< = Height - 2*Border */
  1231.    GLuint Depth2;               /**< = Depth - 2*Border */
  1232.    GLuint WidthLog2;            /**< = log2(Width2) */
  1233.    GLuint HeightLog2;           /**< = log2(Height2) */
  1234.    GLuint DepthLog2;            /**< = log2(Depth2) */
  1235.    GLuint MaxLog2;              /**< = MAX(WidthLog2, HeightLog2) */
  1236.    GLfloat WidthScale;          /**< used for mipmap LOD computation */
  1237.    GLfloat HeightScale;         /**< used for mipmap LOD computation */
  1238.    GLfloat DepthScale;          /**< used for mipmap LOD computation */
  1239.    GLboolean IsClientData;      /**< Data owned by client? */
  1240.    GLboolean _IsPowerOfTwo;     /**< Are all dimensions powers of two? */
  1241.  
  1242.    struct gl_texture_object *TexObject;  /**< Pointer back to parent object */
  1243.  
  1244.    FetchTexelFuncC FetchTexelc; /**< GLchan texel fetch function pointer */
  1245.    FetchTexelFuncF FetchTexelf; /**< Float texel fetch function pointer */
  1246.  
  1247.    GLuint RowStride;            /**< Padded width in units of texels */
  1248.    GLuint *ImageOffsets;        /**< if 3D texture: array [Depth] of offsets to
  1249.                                      each 2D slice in 'Data', in texels */
  1250.    GLvoid *Data;                /**< Image data, accessed via FetchTexel() */
  1251.  
  1252.    /**
  1253.     * \name For device driver:
  1254.     */
  1255.    /*@{*/
  1256.    void *DriverData;            /**< Arbitrary device driver data */
  1257.    /*@}*/
  1258. };
  1259.  
  1260.  
  1261. /**
  1262.  * Indexes for cube map faces.
  1263.  */
  1264. typedef enum
  1265. {
  1266.    FACE_POS_X = 0,
  1267.    FACE_NEG_X = 1,
  1268.    FACE_POS_Y = 2,
  1269.    FACE_NEG_Y = 3,
  1270.    FACE_POS_Z = 4,
  1271.    FACE_NEG_Z = 5,
  1272.    MAX_FACES = 6
  1273. } gl_face_index;
  1274.  
  1275.  
  1276. /**
  1277.  * Texture object state.  Contains the array of mipmap images, border color,
  1278.  * wrap modes, filter modes, shadow/texcompare state, and the per-texture
  1279.  * color palette.
  1280.  */
  1281. struct gl_texture_object
  1282. {
  1283.    _glthread_Mutex Mutex;       /**< for thread safety */
  1284.    GLint RefCount;              /**< reference count */
  1285.    GLuint Name;                 /**< the user-visible texture object ID */
  1286.    GLenum Target;               /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */
  1287.    GLfloat Priority;            /**< in [0,1] */
  1288.    union {
  1289.       GLfloat f[4];
  1290.       GLuint ui[4];
  1291.       GLint i[4];
  1292.    } BorderColor;               /**< Interpreted according to texture format */
  1293.    GLenum WrapS;                /**< S-axis texture image wrap mode */
  1294.    GLenum WrapT;                /**< T-axis texture image wrap mode */
  1295.    GLenum WrapR;                /**< R-axis texture image wrap mode */
  1296.    GLenum MinFilter;            /**< minification filter */
  1297.    GLenum MagFilter;            /**< magnification filter */
  1298.    GLfloat MinLod;              /**< min lambda, OpenGL 1.2 */
  1299.    GLfloat MaxLod;              /**< max lambda, OpenGL 1.2 */
  1300.    GLfloat LodBias;             /**< OpenGL 1.4 */
  1301.    GLint BaseLevel;             /**< min mipmap level, OpenGL 1.2 */
  1302.    GLint MaxLevel;              /**< max mipmap level, OpenGL 1.2 */
  1303.    GLfloat MaxAnisotropy;       /**< GL_EXT_texture_filter_anisotropic */
  1304.    GLenum CompareMode;          /**< GL_ARB_shadow */
  1305.    GLenum CompareFunc;          /**< GL_ARB_shadow */
  1306.    GLfloat CompareFailValue;    /**< GL_ARB_shadow_ambient */
  1307.    GLenum DepthMode;            /**< GL_ARB_depth_texture */
  1308.    GLint _MaxLevel;             /**< actual max mipmap level (q in the spec) */
  1309.    GLfloat _MaxLambda;          /**< = _MaxLevel - BaseLevel (q - b in spec) */
  1310.    GLint CropRect[4];           /**< GL_OES_draw_texture */
  1311.    GLenum Swizzle[4];           /**< GL_EXT_texture_swizzle */
  1312.    GLuint _Swizzle;             /**< same as Swizzle, but SWIZZLE_* format */
  1313.    GLboolean GenerateMipmap;    /**< GL_SGIS_generate_mipmap */
  1314.    GLboolean _Complete;         /**< Is texture object complete? */
  1315.    GLboolean _RenderToTexture;  /**< Any rendering to this texture? */
  1316.    GLboolean Purgeable;         /**< Is the buffer purgeable under memory pressure? */
  1317.  
  1318.    /** Actual texture images, indexed by [cube face] and [mipmap level] */
  1319.    struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS];
  1320.  
  1321.    /** GL_EXT_paletted_texture */
  1322.    struct gl_color_table Palette;
  1323.  
  1324.    /**
  1325.     * \name For device driver.
  1326.     * Note: instead of attaching driver data to this pointer, it's preferable
  1327.     * to instead use this struct as a base class for your own texture object
  1328.     * class.  Driver->NewTextureObject() can be used to implement the
  1329.     * allocation.
  1330.     */
  1331.    void *DriverData;    /**< Arbitrary device driver data */
  1332. };
  1333.  
  1334.  
  1335. /** Up to four combiner sources are possible with GL_NV_texture_env_combine4 */
  1336. #define MAX_COMBINER_TERMS 4
  1337.  
  1338.  
  1339. /**
  1340.  * Texture combine environment state.
  1341.  */
  1342. struct gl_tex_env_combine_state
  1343. {
  1344.    GLenum ModeRGB;       /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
  1345.    GLenum ModeA;         /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
  1346.    /** Source terms: GL_PRIMARY_COLOR, GL_TEXTURE, etc */
  1347.    GLenum SourceRGB[MAX_COMBINER_TERMS];
  1348.    GLenum SourceA[MAX_COMBINER_TERMS];
  1349.    /** Source operands: GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, etc */
  1350.    GLenum OperandRGB[MAX_COMBINER_TERMS];
  1351.    GLenum OperandA[MAX_COMBINER_TERMS];
  1352.    GLuint ScaleShiftRGB; /**< 0, 1 or 2 */
  1353.    GLuint ScaleShiftA;   /**< 0, 1 or 2 */
  1354.    GLuint _NumArgsRGB;   /**< Number of inputs used for the RGB combiner */
  1355.    GLuint _NumArgsA;     /**< Number of inputs used for the A combiner */
  1356. };
  1357.  
  1358.  
  1359. /**
  1360.  * Texture coord generation state.
  1361.  */
  1362. struct gl_texgen
  1363. {
  1364.    GLenum Mode;         /**< GL_EYE_LINEAR, GL_SPHERE_MAP, etc */
  1365.    GLbitfield _ModeBit; /**< TEXGEN_x bit corresponding to Mode */
  1366.    GLfloat ObjectPlane[4];
  1367.    GLfloat EyePlane[4];
  1368. };
  1369.  
  1370.  
  1371. /**
  1372.  * Texture unit state.  Contains enable flags, texture environment/function/
  1373.  * combiners, texgen state, pointers to current texture objects and
  1374.  * post-filter color tables.
  1375.  */
  1376. struct gl_texture_unit
  1377. {
  1378.    GLbitfield Enabled;          /**< bitmask of TEXTURE_*_BIT flags */
  1379.    GLbitfield _ReallyEnabled;   /**< 0 or exactly one of TEXTURE_*_BIT flags */
  1380.  
  1381.    GLenum EnvMode;              /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */
  1382.    GLfloat EnvColor[4];
  1383.  
  1384.    struct gl_texgen GenS;
  1385.    struct gl_texgen GenT;
  1386.    struct gl_texgen GenR;
  1387.    struct gl_texgen GenQ;
  1388.    GLbitfield TexGenEnabled;    /**< Bitwise-OR of [STRQ]_BIT values */
  1389.    GLbitfield _GenFlags;        /**< Bitwise-OR of Gen[STRQ]._ModeBit */
  1390.  
  1391.    GLfloat LodBias;             /**< for biasing mipmap levels */
  1392.    GLenum BumpTarget;
  1393.    GLfloat RotMatrix[4]; /* 2x2 matrix */
  1394.  
  1395.    /**
  1396.     * \name GL_EXT_texture_env_combine
  1397.     */
  1398.    struct gl_tex_env_combine_state Combine;
  1399.  
  1400.    /**
  1401.     * Derived state based on \c EnvMode and the \c BaseFormat of the
  1402.     * currently enabled texture.
  1403.     */
  1404.    struct gl_tex_env_combine_state _EnvMode;
  1405.  
  1406.    /**
  1407.     * Currently enabled combiner state.  This will point to either
  1408.     * \c Combine or \c _EnvMode.
  1409.     */
  1410.    struct gl_tex_env_combine_state *_CurrentCombine;
  1411.  
  1412.    /** Current texture object pointers */
  1413.    struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS];
  1414.  
  1415.    /** Points to highest priority, complete and enabled texture object */
  1416.    struct gl_texture_object *_Current;
  1417.  
  1418.    /** GL_SGI_texture_color_table */
  1419.    /*@{*/
  1420.    struct gl_color_table ColorTable;
  1421.    struct gl_color_table ProxyColorTable;
  1422.    GLboolean ColorTableEnabled;
  1423.    /*@}*/
  1424. };
  1425.  
  1426.  
  1427. /**
  1428.  * Texture attribute group (GL_TEXTURE_BIT).
  1429.  */
  1430. struct gl_texture_attrib
  1431. {
  1432.    GLuint CurrentUnit;   /**< GL_ACTIVE_TEXTURE */
  1433.    struct gl_texture_unit Unit[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
  1434.  
  1435.    struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS];
  1436.  
  1437.    /** GL_ARB_seamless_cubemap */
  1438.    GLboolean CubeMapSeamless;
  1439.  
  1440.    /** GL_EXT_shared_texture_palette */
  1441.    GLboolean SharedPalette;
  1442.    struct gl_color_table Palette;
  1443.  
  1444.    /** Texture units/samplers used by vertex or fragment texturing */
  1445.    GLbitfield _EnabledUnits;
  1446.  
  1447.    /** Texture coord units/sets used for fragment texturing */
  1448.    GLbitfield _EnabledCoordUnits;
  1449.  
  1450.    /** Texture coord units that have texgen enabled */
  1451.    GLbitfield _TexGenEnabled;
  1452.  
  1453.    /** Texture coord units that have non-identity matrices */
  1454.    GLbitfield _TexMatEnabled;
  1455.  
  1456.    /** Bitwise-OR of all Texture.Unit[i]._GenFlags */
  1457.    GLbitfield _GenFlags;
  1458. };
  1459.  
  1460.  
  1461. /**
  1462.  * Transformation attribute group (GL_TRANSFORM_BIT).
  1463.  */
  1464. struct gl_transform_attrib
  1465. {
  1466.    GLenum MatrixMode;                           /**< Matrix mode */
  1467.    GLfloat EyeUserPlane[MAX_CLIP_PLANES][4];    /**< User clip planes */
  1468.    GLfloat _ClipUserPlane[MAX_CLIP_PLANES][4];  /**< derived */
  1469.    GLbitfield ClipPlanesEnabled;                /**< on/off bitmask */
  1470.    GLboolean Normalize;                         /**< Normalize all normals? */
  1471.    GLboolean RescaleNormals;                    /**< GL_EXT_rescale_normal */
  1472.    GLboolean RasterPositionUnclipped;           /**< GL_IBM_rasterpos_clip */
  1473.    GLboolean DepthClamp;                        /**< GL_ARB_depth_clamp */
  1474.  
  1475.    GLfloat CullEyePos[4];
  1476.    GLfloat CullObjPos[4];
  1477. };
  1478.  
  1479.  
  1480. /**
  1481.  * Viewport attribute group (GL_VIEWPORT_BIT).
  1482.  */
  1483. struct gl_viewport_attrib
  1484. {
  1485.    GLint X, Y;                  /**< position */
  1486.    GLsizei Width, Height;       /**< size */
  1487.    GLfloat Near, Far;           /**< Depth buffer range */
  1488.    GLmatrix _WindowMap;         /**< Mapping transformation as a matrix. */
  1489. };
  1490.  
  1491.  
  1492. /**
  1493.  * GL_ARB_vertex/pixel_buffer_object buffer object
  1494.  */
  1495. struct gl_buffer_object
  1496. {
  1497.    _glthread_Mutex Mutex;
  1498.    GLint RefCount;
  1499.    GLuint Name;
  1500.    GLenum Usage;        /**< GL_STREAM_DRAW_ARB, GL_STREAM_READ_ARB, etc. */
  1501.    GLsizeiptrARB Size;  /**< Size of buffer storage in bytes */
  1502.    GLubyte *Data;       /**< Location of storage either in RAM or VRAM. */
  1503.    /** Fields describing a mapped buffer */
  1504.    /*@{*/
  1505.    GLbitfield AccessFlags; /**< Mask of GL_MAP_x_BIT flags */
  1506.    GLvoid *Pointer;     /**< User-space address of mapping */
  1507.    GLintptr Offset;     /**< Mapped offset */
  1508.    GLsizeiptr Length;   /**< Mapped length */
  1509.    /*@}*/
  1510.    GLboolean Written;   /**< Ever written to? (for debugging) */
  1511.    GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */
  1512. };
  1513.  
  1514.  
  1515. /**
  1516.  * Client pixel packing/unpacking attributes
  1517.  */
  1518. struct gl_pixelstore_attrib
  1519. {
  1520.    GLint Alignment;
  1521.    GLint RowLength;
  1522.    GLint SkipPixels;
  1523.    GLint SkipRows;
  1524.    GLint ImageHeight;
  1525.    GLint SkipImages;
  1526.    GLboolean SwapBytes;
  1527.    GLboolean LsbFirst;
  1528.    GLboolean ClientStorage; /**< GL_APPLE_client_storage */
  1529.    GLboolean Invert;        /**< GL_MESA_pack_invert */
  1530.    struct gl_buffer_object *BufferObj; /**< GL_ARB_pixel_buffer_object */
  1531. };
  1532.  
  1533.  
  1534. /**
  1535.  * Client vertex array attributes
  1536.  */
  1537. struct gl_client_array
  1538. {
  1539.    GLint Size;                  /**< components per element (1,2,3,4) */
  1540.    GLenum Type;                 /**< datatype: GL_FLOAT, GL_INT, etc */
  1541.    GLenum Format;               /**< default: GL_RGBA, but may be GL_BGRA */
  1542.    GLsizei Stride;              /**< user-specified stride */
  1543.    GLsizei StrideB;             /**< actual stride in bytes */
  1544.    const GLubyte *Ptr;          /**< Points to array data */
  1545.    GLboolean Enabled;           /**< Enabled flag is a boolean */
  1546.    GLboolean Normalized;        /**< GL_ARB_vertex_program */
  1547.    GLboolean Integer;           /**< Integer-valued? */
  1548.    GLuint _ElementSize;         /**< size of each element in bytes */
  1549.  
  1550.    struct gl_buffer_object *BufferObj;/**< GL_ARB_vertex_buffer_object */
  1551.    GLuint _MaxElement;          /**< max element index into array buffer + 1 */
  1552. };
  1553.  
  1554.  
  1555. /**
  1556.  * Collection of vertex arrays.  Defined by the GL_APPLE_vertex_array_object
  1557.  * extension, but a nice encapsulation in any case.
  1558.  */
  1559. struct gl_array_object
  1560. {
  1561.    /** Name of the array object as received from glGenVertexArrayAPPLE. */
  1562.    GLuint Name;
  1563.  
  1564.    GLint RefCount;
  1565.    _glthread_Mutex Mutex;
  1566.    GLboolean VBOonly;  /**< require all arrays to live in VBOs? */
  1567.  
  1568.    /** Conventional vertex arrays */
  1569.    /*@{*/
  1570.    struct gl_client_array Vertex;
  1571.    struct gl_client_array Weight;
  1572.    struct gl_client_array Normal;
  1573.    struct gl_client_array Color;
  1574.    struct gl_client_array SecondaryColor;
  1575.    struct gl_client_array FogCoord;
  1576.    struct gl_client_array Index;
  1577.    struct gl_client_array EdgeFlag;
  1578.    struct gl_client_array TexCoord[MAX_TEXTURE_COORD_UNITS];
  1579.    struct gl_client_array PointSize;
  1580.    /*@}*/
  1581.  
  1582.    /**
  1583.     * Generic arrays for vertex programs/shaders.
  1584.     * For NV vertex programs, these attributes alias and take priority
  1585.     * over the conventional attribs above.  For ARB vertex programs and
  1586.     * GLSL vertex shaders, these attributes are separate.
  1587.     */
  1588.    struct gl_client_array VertexAttrib[MAX_VERTEX_GENERIC_ATTRIBS];
  1589.  
  1590.    /** Mask of _NEW_ARRAY_* values indicating which arrays are enabled */
  1591.    GLbitfield _Enabled;
  1592.  
  1593.    /**
  1594.     * Min of all enabled arrays' _MaxElement.  When arrays reside inside VBOs
  1595.     * we can determine the max legal (in bounds) glDrawElements array index.
  1596.     */
  1597.    GLuint _MaxElement;
  1598. };
  1599.  
  1600.  
  1601. /**
  1602.  * Vertex array state
  1603.  */
  1604. struct gl_array_attrib
  1605. {
  1606.    /** Currently bound array object. See _mesa_BindVertexArrayAPPLE() */
  1607.    struct gl_array_object *ArrayObj;
  1608.  
  1609.    /** The default vertex array object */
  1610.    struct gl_array_object *DefaultArrayObj;
  1611.  
  1612.    /** Array objects (GL_ARB/APPLE_vertex_array_object) */
  1613.    struct _mesa_HashTable *Objects;
  1614.  
  1615.    GLint ActiveTexture;         /**< Client Active Texture */
  1616.    GLuint LockFirst;            /**< GL_EXT_compiled_vertex_array */
  1617.    GLuint LockCount;            /**< GL_EXT_compiled_vertex_array */
  1618.  
  1619.    /** GL 3.1 (slightly different from GL_NV_primitive_restart) */
  1620.    GLboolean PrimitiveRestart;
  1621.    GLuint RestartIndex;
  1622.  
  1623.    GLbitfield NewState;         /**< mask of _NEW_ARRAY_* values */
  1624.  
  1625.    /* GL_ARB_vertex_buffer_object */
  1626.    struct gl_buffer_object *ArrayBufferObj;
  1627.    struct gl_buffer_object *ElementArrayBufferObj;
  1628. };
  1629.  
  1630.  
  1631. /**
  1632.  * Feedback buffer state
  1633.  */
  1634. struct gl_feedback
  1635. {
  1636.    GLenum Type;
  1637.    GLbitfield _Mask;    /**< FB_* bits */
  1638.    GLfloat *Buffer;
  1639.    GLuint BufferSize;
  1640.    GLuint Count;
  1641. };
  1642.  
  1643.  
  1644. /**
  1645.  * Selection buffer state
  1646.  */
  1647. struct gl_selection
  1648. {
  1649.    GLuint *Buffer;      /**< selection buffer */
  1650.    GLuint BufferSize;   /**< size of the selection buffer */
  1651.    GLuint BufferCount;  /**< number of values in the selection buffer */
  1652.    GLuint Hits;         /**< number of records in the selection buffer */
  1653.    GLuint NameStackDepth; /**< name stack depth */
  1654.    GLuint NameStack[MAX_NAME_STACK_DEPTH]; /**< name stack */
  1655.    GLboolean HitFlag;   /**< hit flag */
  1656.    GLfloat HitMinZ;     /**< minimum hit depth */
  1657.    GLfloat HitMaxZ;     /**< maximum hit depth */
  1658. };
  1659.  
  1660.  
  1661. /**
  1662.  * 1-D Evaluator control points
  1663.  */
  1664. struct gl_1d_map
  1665. {
  1666.    GLuint Order;        /**< Number of control points */
  1667.    GLfloat u1, u2, du;  /**< u1, u2, 1.0/(u2-u1) */
  1668.    GLfloat *Points;     /**< Points to contiguous control points */
  1669. };
  1670.  
  1671.  
  1672. /**
  1673.  * 2-D Evaluator control points
  1674.  */
  1675. struct gl_2d_map
  1676. {
  1677.    GLuint Uorder;               /**< Number of control points in U dimension */
  1678.    GLuint Vorder;               /**< Number of control points in V dimension */
  1679.    GLfloat u1, u2, du;
  1680.    GLfloat v1, v2, dv;
  1681.    GLfloat *Points;             /**< Points to contiguous control points */
  1682. };
  1683.  
  1684.  
  1685. /**
  1686.  * All evaluator control point state
  1687.  */
  1688. struct gl_evaluators
  1689. {
  1690.    /**
  1691.     * \name 1-D maps
  1692.     */
  1693.    /*@{*/
  1694.    struct gl_1d_map Map1Vertex3;
  1695.    struct gl_1d_map Map1Vertex4;
  1696.    struct gl_1d_map Map1Index;
  1697.    struct gl_1d_map Map1Color4;
  1698.    struct gl_1d_map Map1Normal;
  1699.    struct gl_1d_map Map1Texture1;
  1700.    struct gl_1d_map Map1Texture2;
  1701.    struct gl_1d_map Map1Texture3;
  1702.    struct gl_1d_map Map1Texture4;
  1703.    struct gl_1d_map Map1Attrib[16];  /**< GL_NV_vertex_program */
  1704.    /*@}*/
  1705.  
  1706.    /**
  1707.     * \name 2-D maps
  1708.     */
  1709.    /*@{*/
  1710.    struct gl_2d_map Map2Vertex3;
  1711.    struct gl_2d_map Map2Vertex4;
  1712.    struct gl_2d_map Map2Index;
  1713.    struct gl_2d_map Map2Color4;
  1714.    struct gl_2d_map Map2Normal;
  1715.    struct gl_2d_map Map2Texture1;
  1716.    struct gl_2d_map Map2Texture2;
  1717.    struct gl_2d_map Map2Texture3;
  1718.    struct gl_2d_map Map2Texture4;
  1719.    struct gl_2d_map Map2Attrib[16];  /**< GL_NV_vertex_program */
  1720.    /*@}*/
  1721. };
  1722.  
  1723.  
  1724. /**
  1725.  * Names of the various vertex/fragment program register files, etc.
  1726.  *
  1727.  * NOTE: first four tokens must fit into 2 bits (see t_vb_arbprogram.c)
  1728.  * All values should fit in a 4-bit field.
  1729.  *
  1730.  * NOTE: PROGRAM_ENV_PARAM, PROGRAM_STATE_VAR, PROGRAM_NAMED_PARAM,
  1731.  * PROGRAM_CONSTANT, and PROGRAM_UNIFORM can all be considered to
  1732.  * be "uniform" variables since they can only be set outside glBegin/End.
  1733.  * They're also all stored in the same Parameters array.
  1734.  */
  1735. typedef enum
  1736. {
  1737.    PROGRAM_TEMPORARY,   /**< machine->Temporary[] */
  1738.    PROGRAM_INPUT,       /**< machine->Inputs[] */
  1739.    PROGRAM_OUTPUT,      /**< machine->Outputs[] */
  1740.    PROGRAM_VARYING,     /**< machine->Inputs[]/Outputs[] */
  1741.    PROGRAM_LOCAL_PARAM, /**< gl_program->LocalParams[] */
  1742.    PROGRAM_ENV_PARAM,   /**< gl_program->Parameters[] */
  1743.    PROGRAM_STATE_VAR,   /**< gl_program->Parameters[] */
  1744.    PROGRAM_NAMED_PARAM, /**< gl_program->Parameters[] */
  1745.    PROGRAM_CONSTANT,    /**< gl_program->Parameters[] */
  1746.    PROGRAM_UNIFORM,     /**< gl_program->Parameters[] */
  1747.    PROGRAM_WRITE_ONLY,  /**< A dummy, write-only register */
  1748.    PROGRAM_ADDRESS,     /**< machine->AddressReg */
  1749.    PROGRAM_SAMPLER,     /**< for shader samplers, compile-time only */
  1750.    PROGRAM_UNDEFINED,   /**< Invalid/TBD value */
  1751.    PROGRAM_FILE_MAX
  1752. } gl_register_file;
  1753.  
  1754.  
  1755. /** Vertex and fragment instructions */
  1756. struct prog_instruction;
  1757. struct gl_program_parameter_list;
  1758. struct gl_uniform_list;
  1759.  
  1760.  
  1761. /**
  1762.  * Base class for any kind of program object
  1763.  */
  1764. struct gl_program
  1765. {
  1766.    GLuint Id;
  1767.    GLubyte *String;  /**< Null-terminated program text */
  1768.    GLint RefCount;
  1769.    GLenum Target;    /**< GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_FRAGMENT_PROGRAM_NV */
  1770.    GLenum Format;    /**< String encoding format */
  1771.    GLboolean Resident;
  1772.  
  1773.    struct prog_instruction *Instructions;
  1774.  
  1775.    GLbitfield InputsRead;     /**< Bitmask of which input regs are read */
  1776.    GLbitfield64 OutputsWritten; /**< Bitmask of which output regs are written */
  1777.    GLbitfield InputFlags[MAX_PROGRAM_INPUTS];   /**< PROG_PARAM_BIT_x flags */
  1778.    GLbitfield OutputFlags[MAX_PROGRAM_OUTPUTS]; /**< PROG_PARAM_BIT_x flags */
  1779.    GLbitfield TexturesUsed[MAX_TEXTURE_UNITS];  /**< TEXTURE_x_BIT bitmask */
  1780.    GLbitfield SamplersUsed;   /**< Bitfield of which samplers are used */
  1781.    GLbitfield ShadowSamplers; /**< Texture units used for shadow sampling. */
  1782.  
  1783.  
  1784.    /** Named parameters, constants, etc. from program text */
  1785.    struct gl_program_parameter_list *Parameters;
  1786.    /** Numbered local parameters */
  1787.    GLfloat LocalParams[MAX_PROGRAM_LOCAL_PARAMS][4];
  1788.  
  1789.    /** Vertex/fragment shader varying vars */
  1790.    struct gl_program_parameter_list *Varying;
  1791.    /** Vertex program user-defined attributes */
  1792.    struct gl_program_parameter_list *Attributes;
  1793.  
  1794.    /** Map from sampler unit to texture unit (set by glUniform1i()) */
  1795.    GLubyte SamplerUnits[MAX_SAMPLERS];
  1796.    /** Which texture target is being sampled (TEXTURE_1D/2D/3D/etc_INDEX) */
  1797.    gl_texture_index SamplerTargets[MAX_SAMPLERS];
  1798.  
  1799.    /** Bitmask of which register files are read/written with indirect
  1800.     * addressing.  Mask of (1 << PROGRAM_x) bits.
  1801.     */
  1802.    GLbitfield IndirectRegisterFiles;
  1803.  
  1804.    /** Logical counts */
  1805.    /*@{*/
  1806.    GLuint NumInstructions;
  1807.    GLuint NumTemporaries;
  1808.    GLuint NumParameters;
  1809.    GLuint NumAttributes;
  1810.    GLuint NumAddressRegs;
  1811.    GLuint NumAluInstructions;
  1812.    GLuint NumTexInstructions;
  1813.    GLuint NumTexIndirections;
  1814.    /*@}*/
  1815.    /** Native, actual h/w counts */
  1816.    /*@{*/
  1817.    GLuint NumNativeInstructions;
  1818.    GLuint NumNativeTemporaries;
  1819.    GLuint NumNativeParameters;
  1820.    GLuint NumNativeAttributes;
  1821.    GLuint NumNativeAddressRegs;
  1822.    GLuint NumNativeAluInstructions;
  1823.    GLuint NumNativeTexInstructions;
  1824.    GLuint NumNativeTexIndirections;
  1825.    /*@}*/
  1826. };
  1827.  
  1828.  
  1829. /** Vertex program object */
  1830. struct gl_vertex_program
  1831. {
  1832.    struct gl_program Base;   /**< base class */
  1833.    GLboolean IsNVProgram;    /**< is this a GL_NV_vertex_program program? */
  1834.    GLboolean IsPositionInvariant;
  1835. };
  1836.  
  1837.  
  1838. /** Geometry program object */
  1839. struct gl_geometry_program
  1840. {
  1841.    struct gl_program Base;   /**< base class */
  1842.  
  1843.    GLint VerticesOut;
  1844.    GLenum InputType;  /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB,
  1845.                            GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */
  1846.    GLenum OutputType; /**< GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP */
  1847. };
  1848.  
  1849.  
  1850. /** Fragment program object */
  1851. struct gl_fragment_program
  1852. {
  1853.    struct gl_program Base;   /**< base class */
  1854.    GLenum FogOption;
  1855.    GLboolean UsesKill;          /**< shader uses KIL instruction */
  1856.    GLboolean OriginUpperLeft;
  1857.    GLboolean PixelCenterInteger;
  1858. };
  1859.  
  1860.  
  1861. /**
  1862.  * State common to vertex and fragment programs.
  1863.  */
  1864. struct gl_program_state
  1865. {
  1866.    GLint ErrorPos;                       /* GL_PROGRAM_ERROR_POSITION_ARB/NV */
  1867.    const char *ErrorString;              /* GL_PROGRAM_ERROR_STRING_ARB/NV */
  1868. };
  1869.  
  1870.  
  1871. /**
  1872.  * Context state for vertex programs.
  1873.  */
  1874. struct gl_vertex_program_state
  1875. {
  1876.    GLboolean Enabled;            /**< User-set GL_VERTEX_PROGRAM_ARB/NV flag */
  1877.    GLboolean _Enabled;           /**< Enabled and _valid_ user program? */
  1878.    GLboolean PointSizeEnabled;   /**< GL_VERTEX_PROGRAM_POINT_SIZE_ARB/NV */
  1879.    GLboolean TwoSideEnabled;     /**< GL_VERTEX_PROGRAM_TWO_SIDE_ARB/NV */
  1880.    struct gl_vertex_program *Current;  /**< User-bound vertex program */
  1881.  
  1882.    /** Currently enabled and valid vertex program (including internal
  1883.     * programs, user-defined vertex programs and GLSL vertex shaders).
  1884.     * This is the program we must use when rendering.
  1885.     */
  1886.    struct gl_vertex_program *_Current;
  1887.  
  1888.    GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */
  1889.  
  1890.    /* For GL_NV_vertex_program only: */
  1891.    GLenum TrackMatrix[MAX_PROGRAM_ENV_PARAMS / 4];
  1892.    GLenum TrackMatrixTransform[MAX_PROGRAM_ENV_PARAMS / 4];
  1893.  
  1894.    /** Should fixed-function T&L be implemented with a vertex prog? */
  1895.    GLboolean _MaintainTnlProgram;
  1896.  
  1897.    /** Program to emulate fixed-function T&L (see above) */
  1898.    struct gl_vertex_program *_TnlProgram;
  1899.  
  1900.    /** Cache of fixed-function programs */
  1901.    struct gl_program_cache *Cache;
  1902.  
  1903.    GLboolean _Overriden;
  1904. };
  1905.  
  1906.  
  1907. /**
  1908.  * Context state for geometry programs.
  1909.  */
  1910. struct gl_geometry_program_state
  1911. {
  1912.    GLboolean Enabled;               /**< GL_ARB_GEOMETRY_SHADER4 */
  1913.    GLboolean _Enabled;              /**< Enabled and valid program? */
  1914.    struct gl_geometry_program *Current;  /**< user-bound geometry program */
  1915.  
  1916.    /** Currently enabled and valid program (including internal programs
  1917.     * and compiled shader programs).
  1918.     */
  1919.    struct gl_geometry_program *_Current;
  1920.  
  1921.    GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */
  1922.  
  1923.    /** Cache of fixed-function programs */
  1924.    struct gl_program_cache *Cache;
  1925. };
  1926.  
  1927. /**
  1928.  * Context state for fragment programs.
  1929.  */
  1930. struct gl_fragment_program_state
  1931. {
  1932.    GLboolean Enabled;     /**< User-set fragment program enable flag */
  1933.    GLboolean _Enabled;    /**< Enabled and _valid_ user program? */
  1934.    struct gl_fragment_program *Current;  /**< User-bound fragment program */
  1935.  
  1936.    /** Currently enabled and valid fragment program (including internal
  1937.     * programs, user-defined fragment programs and GLSL fragment shaders).
  1938.     * This is the program we must use when rendering.
  1939.     */
  1940.    struct gl_fragment_program *_Current;
  1941.  
  1942.    GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */
  1943.  
  1944.    /** Should fixed-function texturing be implemented with a fragment prog? */
  1945.    GLboolean _MaintainTexEnvProgram;
  1946.  
  1947.    /** Program to emulate fixed-function texture env/combine (see above) */
  1948.    struct gl_fragment_program *_TexEnvProgram;
  1949.  
  1950.    /** Cache of fixed-function programs */
  1951.    struct gl_program_cache *Cache;
  1952. };
  1953.  
  1954.  
  1955. /**
  1956.  * ATI_fragment_shader runtime state
  1957.  */
  1958. #define ATI_FS_INPUT_PRIMARY 0
  1959. #define ATI_FS_INPUT_SECONDARY 1
  1960.  
  1961. struct atifs_instruction;
  1962. struct atifs_setupinst;
  1963.  
  1964. /**
  1965.  * ATI fragment shader
  1966.  */
  1967. struct ati_fragment_shader
  1968. {
  1969.    GLuint Id;
  1970.    GLint RefCount;
  1971.    struct atifs_instruction *Instructions[2];
  1972.    struct atifs_setupinst *SetupInst[2];
  1973.    GLfloat Constants[8][4];
  1974.    GLbitfield LocalConstDef;  /**< Indicates which constants have been set */
  1975.    GLubyte numArithInstr[2];
  1976.    GLubyte regsAssigned[2];
  1977.    GLubyte NumPasses;         /**< 1 or 2 */
  1978.    GLubyte cur_pass;
  1979.    GLubyte last_optype;
  1980.    GLboolean interpinp1;
  1981.    GLboolean isValid;
  1982.    GLuint swizzlerq;
  1983. };
  1984.  
  1985. /**
  1986.  * Context state for GL_ATI_fragment_shader
  1987.  */
  1988. struct gl_ati_fragment_shader_state
  1989. {
  1990.    GLboolean Enabled;
  1991.    GLboolean _Enabled;                  /**< enabled and valid shader? */
  1992.    GLboolean Compiling;
  1993.    GLfloat GlobalConstants[8][4];
  1994.    struct ati_fragment_shader *Current;
  1995. };
  1996.  
  1997.  
  1998. /**
  1999.  * Occlusion/timer query object.
  2000.  */
  2001. struct gl_query_object
  2002. {
  2003.    GLenum Target;      /**< The query target, when active */
  2004.    GLuint Id;          /**< hash table ID/name */
  2005.    GLuint64EXT Result; /**< the counter */
  2006.    GLboolean Active;   /**< inside Begin/EndQuery */
  2007.    GLboolean Ready;    /**< result is ready? */
  2008. };
  2009.  
  2010.  
  2011. /**
  2012.  * Context state for query objects.
  2013.  */
  2014. struct gl_query_state
  2015. {
  2016.    struct _mesa_HashTable *QueryObjects;
  2017.    struct gl_query_object *CurrentOcclusionObject; /* GL_ARB_occlusion_query */
  2018.    struct gl_query_object *CurrentTimerObject;     /* GL_EXT_timer_query */
  2019.  
  2020.    /** GL_NV_conditional_render */
  2021.    struct gl_query_object *CondRenderQuery;
  2022.  
  2023.    /** GL_EXT_transform_feedback */
  2024.    struct gl_query_object *PrimitivesGenerated;
  2025.    struct gl_query_object *PrimitivesWritten;
  2026.  
  2027.    /** GL_ARB_timer_query */
  2028.    struct gl_query_object *TimeElapsed;
  2029.  
  2030.    GLenum CondRenderMode;
  2031. };
  2032.  
  2033.  
  2034. /** Sync object state */
  2035. struct gl_sync_object {
  2036.    struct simple_node link;
  2037.    GLenum Type;               /**< GL_SYNC_FENCE */
  2038.    GLuint Name;               /**< Fence name */
  2039.    GLint RefCount;            /**< Reference count */
  2040.    GLboolean DeletePending;   /**< Object was deleted while there were still
  2041.                                * live references (e.g., sync not yet finished)
  2042.                                */
  2043.    GLenum SyncCondition;
  2044.    GLbitfield Flags;          /**< Flags passed to glFenceSync */
  2045.    GLuint StatusFlag:1;       /**< Has the sync object been signaled? */
  2046. };
  2047.  
  2048.  
  2049. /** Set by #pragma directives */
  2050. struct gl_sl_pragmas
  2051. {
  2052.    GLboolean IgnoreOptimize;  /**< ignore #pragma optimize(on/off) ? */
  2053.    GLboolean IgnoreDebug;     /**< ignore #pragma debug(on/off) ? */
  2054.    GLboolean Optimize;  /**< defaults on */
  2055.    GLboolean Debug;     /**< defaults off */
  2056. };
  2057.  
  2058.  
  2059. /**
  2060.  * A GLSL vertex or fragment shader object.
  2061.  */
  2062. struct gl_shader
  2063. {
  2064.    GLenum Type;  /**< GL_FRAGMENT_SHADER || GL_VERTEX_SHADER || GL_GEOMETRY_SHADER_ARB (first field!) */
  2065.    GLuint Name;  /**< AKA the handle */
  2066.    GLint RefCount;  /**< Reference count */
  2067.    GLboolean DeletePending;
  2068.    GLboolean CompileStatus;
  2069.    GLboolean Main;  /**< shader defines main() */
  2070.    GLboolean UnresolvedRefs;
  2071.    const GLchar *Source;  /**< Source code string */
  2072.    GLuint SourceChecksum;       /**< for debug/logging purposes */
  2073.    struct gl_program *Program;  /**< Post-compile assembly code */
  2074.    GLchar *InfoLog;
  2075.    struct gl_sl_pragmas Pragmas;
  2076.  
  2077.    unsigned Version;       /**< GLSL version used for linking */
  2078.  
  2079.    struct exec_list *ir;
  2080.    struct glsl_symbol_table *symbols;
  2081.  
  2082.    /** Shaders containing built-in functions that are used for linking. */
  2083.    struct gl_shader *builtins_to_link[16];
  2084.    unsigned num_builtins_to_link;
  2085. };
  2086.  
  2087.  
  2088. /**
  2089.  * A GLSL program object.
  2090.  * Basically a linked collection of vertex and fragment shaders.
  2091.  */
  2092. struct gl_shader_program
  2093. {
  2094.    GLenum Type;  /**< Always GL_SHADER_PROGRAM (internal token) */
  2095.    GLuint Name;  /**< aka handle or ID */
  2096.    GLint RefCount;  /**< Reference count */
  2097.    GLboolean DeletePending;
  2098.  
  2099.    GLuint NumShaders;          /**< number of attached shaders */
  2100.    struct gl_shader **Shaders; /**< List of attached the shaders */
  2101.  
  2102.    /** User-defined attribute bindings (glBindAttribLocation) */
  2103.    struct gl_program_parameter_list *Attributes;
  2104.  
  2105.    /** Transform feedback varyings */
  2106.    struct {
  2107.       GLenum BufferMode;
  2108.       GLuint NumVarying;
  2109.       GLchar **VaryingNames;  /**< Array [NumVarying] of char * */
  2110.    } TransformFeedback;
  2111.  
  2112.    /** Geometry shader state - copied into gl_geometry_program at link time */
  2113.    struct {
  2114.       GLint VerticesOut;
  2115.       GLenum InputType;  /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB,
  2116.                               GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */
  2117.       GLenum OutputType; /**< GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP */
  2118.    } Geom;
  2119.  
  2120.    /* post-link info: */
  2121.    struct gl_vertex_program *VertexProgram;     /**< Linked vertex program */
  2122.    struct gl_fragment_program *FragmentProgram; /**< Linked fragment prog */
  2123.    struct gl_geometry_program *GeometryProgram; /**< Linked geometry prog */
  2124.    struct gl_uniform_list *Uniforms;
  2125.    struct gl_program_parameter_list *Varying;
  2126.    GLboolean LinkStatus;   /**< GL_LINK_STATUS */
  2127.    GLboolean Validated;
  2128.    GLboolean _Used;        /**< Ever used for drawing? */
  2129.    GLchar *InfoLog;
  2130.  
  2131.    unsigned Version;       /**< GLSL version used for linking */
  2132.  
  2133.    /**
  2134.     * Per-stage shaders resulting from the first stage of linking.
  2135.     *
  2136.     * Set of linked shaders for this program.  The array is accessed using the
  2137.     * \c MESA_SHADER_* defines.  Entries for non-existent stages will be
  2138.     * \c NULL.
  2139.     */
  2140.    struct gl_shader *_LinkedShaders[MESA_SHADER_TYPES];
  2141. };
  2142.  
  2143.  
  2144. #define GLSL_DUMP      0x1  /**< Dump shaders to stdout */
  2145. #define GLSL_LOG       0x2  /**< Write shaders to files */
  2146. #define GLSL_OPT       0x4  /**< Force optimizations (override pragmas) */
  2147. #define GLSL_NO_OPT    0x8  /**< Force no optimizations (override pragmas) */
  2148. #define GLSL_UNIFORMS 0x10  /**< Print glUniform calls */
  2149. #define GLSL_NOP_VERT 0x20  /**< Force no-op vertex shaders */
  2150. #define GLSL_NOP_FRAG 0x40  /**< Force no-op fragment shaders */
  2151. #define GLSL_USE_PROG 0x80  /**< Log glUseProgram calls */
  2152.  
  2153.  
  2154. /**
  2155.  * Context state for GLSL vertex/fragment shaders.
  2156.  */
  2157. struct gl_shader_state
  2158. {
  2159.    /**
  2160.     * Programs used for rendering
  2161.     *
  2162.     * There is a separate program set for each shader stage.  If
  2163.     * GL_EXT_separate_shader_objects is not supported, each of these must point
  2164.     * to \c NULL or to the same program.
  2165.     */
  2166.    struct gl_shader_program *CurrentVertexProgram;
  2167.    struct gl_shader_program *CurrentGeometryProgram;
  2168.    struct gl_shader_program *CurrentFragmentProgram;
  2169.  
  2170.    /**
  2171.     * Program used by glUniform calls.
  2172.     *
  2173.     * Explicitly set by \c glUseProgram and \c glActiveProgramEXT.
  2174.     */
  2175.    struct gl_shader_program *ActiveProgram;
  2176.  
  2177.    void *MemPool;
  2178.  
  2179.    GLbitfield Flags;                    /**< Mask of GLSL_x flags */
  2180. };
  2181.  
  2182. /**
  2183.  * Compiler options for a single GLSL shaders type
  2184.  */
  2185. struct gl_shader_compiler_options
  2186. {
  2187.    /** Driver-selectable options: */
  2188.    GLboolean EmitCondCodes;             /**< Use condition codes? */
  2189.    GLboolean EmitNVTempInitialization;  /**< 0-fill NV temp registers */
  2190.    /**
  2191.     * Attempts to flatten all ir_if (OPCODE_IF) for GPUs that can't
  2192.     * support control flow.
  2193.     */
  2194.    GLboolean EmitNoIfs;
  2195.    GLboolean EmitNoLoops;
  2196.    GLboolean EmitNoFunctions;
  2197.    GLboolean EmitNoCont;                  /**< Emit CONT opcode? */
  2198.    GLboolean EmitNoMainReturn;            /**< Emit CONT/RET opcodes? */
  2199.    GLboolean EmitNoNoise;                 /**< Emit NOISE opcodes? */
  2200.    GLboolean EmitNoPow;                   /**< Emit POW opcodes? */
  2201.  
  2202.    /**
  2203.     * \name Forms of indirect addressing the driver cannot do.
  2204.     */
  2205.    /*@{*/
  2206.    GLboolean EmitNoIndirectInput;   /**< No indirect addressing of inputs */
  2207.    GLboolean EmitNoIndirectOutput;  /**< No indirect addressing of outputs */
  2208.    GLboolean EmitNoIndirectTemp;    /**< No indirect addressing of temps */
  2209.    GLboolean EmitNoIndirectUniform; /**< No indirect addressing of constants */
  2210.    /*@}*/
  2211.  
  2212.    GLuint MaxUnrollIterations;
  2213.  
  2214.    struct gl_sl_pragmas DefaultPragmas; /**< Default #pragma settings */
  2215. };
  2216.  
  2217. /**
  2218.  * Transform feedback object state
  2219.  */
  2220. struct gl_transform_feedback_object
  2221. {
  2222.    GLuint Name;  /**< AKA the object ID */
  2223.    GLint RefCount;
  2224.    GLboolean Active;  /**< Is transform feedback enabled? */
  2225.    GLboolean Paused;  /**< Is transform feedback paused? */
  2226.  
  2227.    /** The feedback buffers */
  2228.    GLuint BufferNames[MAX_FEEDBACK_ATTRIBS];
  2229.    struct gl_buffer_object *Buffers[MAX_FEEDBACK_ATTRIBS];
  2230.  
  2231.    /** Start of feedback data in dest buffer */
  2232.    GLintptr Offset[MAX_FEEDBACK_ATTRIBS];
  2233.    /** Max data to put into dest buffer (in bytes) */
  2234.    GLsizeiptr Size[MAX_FEEDBACK_ATTRIBS];
  2235. };
  2236.  
  2237.  
  2238. /**
  2239.  * Context state for transform feedback.
  2240.  */
  2241. struct gl_transform_feedback
  2242. {
  2243.    GLenum Mode;       /**< GL_POINTS, GL_LINES or GL_TRIANGLES */
  2244.  
  2245.    GLboolean RasterDiscard;  /**< GL_RASTERIZER_DISCARD */
  2246.  
  2247.    /** The general binding point (GL_TRANSFORM_FEEDBACK_BUFFER) */
  2248.    struct gl_buffer_object *CurrentBuffer;
  2249.  
  2250.    /** The table of all transform feedback objects */
  2251.    struct _mesa_HashTable *Objects;
  2252.  
  2253.    /** The current xform-fb object (GL_TRANSFORM_FEEDBACK_BINDING) */
  2254.    struct gl_transform_feedback_object *CurrentObject;
  2255.  
  2256.    /** The default xform-fb object (Name==0) */
  2257.    struct gl_transform_feedback_object *DefaultObject;
  2258. };
  2259.  
  2260.  
  2261.  
  2262. /**
  2263.  * State which can be shared by multiple contexts:
  2264.  */
  2265. struct gl_shared_state
  2266. {
  2267.    _glthread_Mutex Mutex;                  /**< for thread safety */
  2268.    GLint RefCount;                         /**< Reference count */
  2269.    struct _mesa_HashTable *DisplayList;    /**< Display lists hash table */
  2270.    struct _mesa_HashTable *TexObjects;     /**< Texture objects hash table */
  2271.  
  2272.    /** Default texture objects (shared by all texture units) */
  2273.    struct gl_texture_object *DefaultTex[NUM_TEXTURE_TARGETS];
  2274.  
  2275.    /** Fallback texture used when a bound texture is incomplete */
  2276.    struct gl_texture_object *FallbackTex;
  2277.  
  2278.    /**
  2279.     * \name Thread safety and statechange notification for texture
  2280.     * objects.
  2281.     *
  2282.     * \todo Improve the granularity of locking.
  2283.     */
  2284.    /*@{*/
  2285.    _glthread_Mutex TexMutex;            /**< texobj thread safety */
  2286.    GLuint TextureStateStamp;            /**< state notification for shared tex */
  2287.    /*@}*/
  2288.  
  2289.    /** Default buffer object for vertex arrays that aren't in VBOs */
  2290.    struct gl_buffer_object *NullBufferObj;
  2291.  
  2292.    /**
  2293.     * \name Vertex/geometry/fragment programs
  2294.     */
  2295.    /*@{*/
  2296.    struct _mesa_HashTable *Programs; /**< All vertex/fragment programs */
  2297.    struct gl_vertex_program *DefaultVertexProgram;
  2298.    struct gl_fragment_program *DefaultFragmentProgram;
  2299.    struct gl_geometry_program *DefaultGeometryProgram;
  2300.    /*@}*/
  2301.  
  2302.    /* GL_ATI_fragment_shader */
  2303.    struct _mesa_HashTable *ATIShaders;
  2304.    struct ati_fragment_shader *DefaultFragmentShader;
  2305.  
  2306.    struct _mesa_HashTable *BufferObjects;
  2307.  
  2308.    /** Table of both gl_shader and gl_shader_program objects */
  2309.    struct _mesa_HashTable *ShaderObjects;
  2310.  
  2311.    /* GL_EXT_framebuffer_object */
  2312.    struct _mesa_HashTable *RenderBuffers;
  2313.    struct _mesa_HashTable *FrameBuffers;
  2314.  
  2315.    /* GL_ARB_sync */
  2316.    struct simple_node SyncObjects;
  2317.  
  2318.    void *DriverData;  /**< Device driver shared state */
  2319. };
  2320.  
  2321.  
  2322.  
  2323.  
  2324. /**
  2325.  * A renderbuffer stores colors or depth values or stencil values.
  2326.  * A framebuffer object will have a collection of these.
  2327.  * Data are read/written to the buffer with a handful of Get/Put functions.
  2328.  *
  2329.  * Instances of this object are allocated with the Driver's NewRenderbuffer
  2330.  * hook.  Drivers will likely wrap this class inside a driver-specific
  2331.  * class to simulate inheritance.
  2332.  */
  2333. struct gl_renderbuffer
  2334. {
  2335. #define RB_MAGIC 0xaabbccdd
  2336.    int Magic; /** XXX TEMPORARY DEBUG INFO */
  2337.    _glthread_Mutex Mutex;                  /**< for thread safety */
  2338.    GLuint ClassID;        /**< Useful for drivers */
  2339.    GLuint Name;
  2340.    GLint RefCount;
  2341.    GLuint Width, Height;
  2342.    GLboolean Purgeable;   /**< Is the buffer purgeable under memory pressure? */
  2343.  
  2344.    GLenum InternalFormat; /**< The user-specified format */
  2345.    GLenum _BaseFormat;    /**< Either GL_RGB, GL_RGBA, GL_DEPTH_COMPONENT or
  2346.                                GL_STENCIL_INDEX. */
  2347.    GLuint Format;         /**< The actual format: MESA_FORMAT_x */
  2348.  
  2349.    GLubyte NumSamples;
  2350.  
  2351.    GLenum DataType;      /**< Type of values passed to the Get/Put functions */
  2352.    GLvoid *Data;        /**< This may not be used by some kinds of RBs */
  2353.  
  2354.    /* Used to wrap one renderbuffer around another: */
  2355.    struct gl_renderbuffer *Wrapped;
  2356.  
  2357.    /* Delete this renderbuffer */
  2358.    void (*Delete)(struct gl_renderbuffer *rb);
  2359.  
  2360.    /* Allocate new storage for this renderbuffer */
  2361.    GLboolean (*AllocStorage)(struct gl_context *ctx, struct gl_renderbuffer *rb,
  2362.                              GLenum internalFormat,
  2363.                              GLuint width, GLuint height);
  2364.  
  2365.    /* Lock/Unlock are called before/after calling the Get/Put functions.
  2366.     * Not sure this is the right place for these yet.
  2367.    void (*Lock)(struct gl_context *ctx, struct gl_renderbuffer *rb);
  2368.    void (*Unlock)(struct gl_context *ctx, struct gl_renderbuffer *rb);
  2369.     */
  2370.  
  2371.    /* Return a pointer to the element/pixel at (x,y).
  2372.     * Should return NULL if the buffer memory can't be directly addressed.
  2373.     */
  2374.    void *(*GetPointer)(struct gl_context *ctx, struct gl_renderbuffer *rb,
  2375.                        GLint x, GLint y);
  2376.  
  2377.    /* Get/Read a row of values.
  2378.     * The values will be of format _BaseFormat and type DataType.
  2379.     */
  2380.    void (*GetRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
  2381.                   GLint x, GLint y, void *values);
  2382.  
  2383.    /* Get/Read values at arbitrary locations.
  2384.     * The values will be of format _BaseFormat and type DataType.
  2385.     */
  2386.    void (*GetValues)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
  2387.                      const GLint x[], const GLint y[], void *values);
  2388.  
  2389.    /* Put/Write a row of values.
  2390.     * The values will be of format _BaseFormat and type DataType.
  2391.     */
  2392.    void (*PutRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
  2393.                   GLint x, GLint y, const void *values, const GLubyte *mask);
  2394.  
  2395.    /* Put/Write a row of RGB values.  This is a special-case routine that's
  2396.     * only used for RGBA renderbuffers when the source data is GL_RGB. That's
  2397.     * a common case for glDrawPixels and some triangle routines.
  2398.     * The values will be of format GL_RGB and type DataType.
  2399.     */
  2400.    void (*PutRowRGB)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
  2401.                     GLint x, GLint y, const void *values, const GLubyte *mask);
  2402.  
  2403.  
  2404.    /* Put/Write a row of identical values.
  2405.     * The values will be of format _BaseFormat and type DataType.
  2406.     */
  2407.    void (*PutMonoRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
  2408.                      GLint x, GLint y, const void *value, const GLubyte *mask);
  2409.  
  2410.    /* Put/Write values at arbitrary locations.
  2411.     * The values will be of format _BaseFormat and type DataType.
  2412.     */
  2413.    void (*PutValues)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
  2414.                      const GLint x[], const GLint y[], const void *values,
  2415.                      const GLubyte *mask);
  2416.    /* Put/Write identical values at arbitrary locations.
  2417.     * The values will be of format _BaseFormat and type DataType.
  2418.     */
  2419.    void (*PutMonoValues)(struct gl_context *ctx, struct gl_renderbuffer *rb,
  2420.                          GLuint count, const GLint x[], const GLint y[],
  2421.                          const void *value, const GLubyte *mask);
  2422. };
  2423.  
  2424.  
  2425. /**
  2426.  * A renderbuffer attachment points to either a texture object (and specifies
  2427.  * a mipmap level, cube face or 3D texture slice) or points to a renderbuffer.
  2428.  */
  2429. struct gl_renderbuffer_attachment
  2430. {
  2431.    GLenum Type;  /**< \c GL_NONE or \c GL_TEXTURE or \c GL_RENDERBUFFER_EXT */
  2432.    GLboolean Complete;
  2433.  
  2434.    /**
  2435.     * If \c Type is \c GL_RENDERBUFFER_EXT, this stores a pointer to the
  2436.     * application supplied renderbuffer object.
  2437.     */
  2438.    struct gl_renderbuffer *Renderbuffer;
  2439.  
  2440.    /**
  2441.     * If \c Type is \c GL_TEXTURE, this stores a pointer to the application
  2442.     * supplied texture object.
  2443.     */
  2444.    struct gl_texture_object *Texture;
  2445.    GLuint TextureLevel; /**< Attached mipmap level. */
  2446.    GLuint CubeMapFace;  /**< 0 .. 5, for cube map textures. */
  2447.    GLuint Zoffset;      /**< Slice for 3D textures,  or layer for both 1D
  2448.                          * and 2D array textures */
  2449. };
  2450.  
  2451.  
  2452. /**
  2453.  * A framebuffer is a collection of renderbuffers (color, depth, stencil, etc).
  2454.  * In C++ terms, think of this as a base class from which device drivers
  2455.  * will make derived classes.
  2456.  */
  2457. struct gl_framebuffer
  2458. {
  2459.    _glthread_Mutex Mutex;  /**< for thread safety */
  2460.    /**
  2461.     * If zero, this is a window system framebuffer.  If non-zero, this
  2462.     * is a FBO framebuffer; note that for some devices (i.e. those with
  2463.     * a natural pixel coordinate system for FBOs that differs from the
  2464.     * OpenGL/Mesa coordinate system), this means that the viewport,
  2465.     * polygon face orientation, and polygon stipple will have to be inverted.
  2466.     */
  2467.    GLuint Name;
  2468.  
  2469.    GLint RefCount;
  2470.    GLboolean DeletePending;
  2471.  
  2472.    /**
  2473.     * The framebuffer's visual. Immutable if this is a window system buffer.
  2474.     * Computed from attachments if user-made FBO.
  2475.     */
  2476.    struct gl_config Visual;
  2477.  
  2478.    GLboolean Initialized;
  2479.  
  2480.    GLuint Width, Height;        /**< size of frame buffer in pixels */
  2481.  
  2482.    /** \name  Drawing bounds (Intersection of buffer size and scissor box) */
  2483.    /*@{*/
  2484.    GLint _Xmin, _Xmax;  /**< inclusive */
  2485.    GLint _Ymin, _Ymax;  /**< exclusive */
  2486.    /*@}*/
  2487.  
  2488.    /** \name  Derived Z buffer stuff */
  2489.    /*@{*/
  2490.    GLuint _DepthMax;    /**< Max depth buffer value */
  2491.    GLfloat _DepthMaxF;  /**< Float max depth buffer value */
  2492.    GLfloat _MRD;        /**< minimum resolvable difference in Z values */
  2493.    /*@}*/
  2494.  
  2495.    /** One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */
  2496.    GLenum _Status;
  2497.  
  2498.    /** Integer color values */
  2499.    GLboolean _IntegerColor;
  2500.  
  2501.    /** Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */
  2502.    struct gl_renderbuffer_attachment Attachment[BUFFER_COUNT];
  2503.  
  2504.    /* In unextended OpenGL these vars are part of the GL_COLOR_BUFFER
  2505.     * attribute group and GL_PIXEL attribute group, respectively.
  2506.     */
  2507.    GLenum ColorDrawBuffer[MAX_DRAW_BUFFERS];
  2508.    GLenum ColorReadBuffer;
  2509.  
  2510.    /** Computed from ColorDraw/ReadBuffer above */
  2511.    GLuint _NumColorDrawBuffers;
  2512.    GLint _ColorDrawBufferIndexes[MAX_DRAW_BUFFERS]; /**< BUFFER_x or -1 */
  2513.    GLint _ColorReadBufferIndex; /* -1 = None */
  2514.    struct gl_renderbuffer *_ColorDrawBuffers[MAX_DRAW_BUFFERS];
  2515.    struct gl_renderbuffer *_ColorReadBuffer;
  2516.  
  2517.    /** The Actual depth/stencil buffers to use.  May be wrappers around the
  2518.     * depth/stencil buffers attached above. */
  2519.    struct gl_renderbuffer *_DepthBuffer;
  2520.    struct gl_renderbuffer *_StencilBuffer;
  2521.  
  2522.    /** Delete this framebuffer */
  2523.    void (*Delete)(struct gl_framebuffer *fb);
  2524. };
  2525.  
  2526.  
  2527. /**
  2528.  * Precision info for shader datatypes.  See glGetShaderPrecisionFormat().
  2529.  */
  2530. struct gl_precision
  2531. {
  2532.    GLushort RangeMin;   /**< min value exponent */
  2533.    GLushort RangeMax;   /**< max value exponent */
  2534.    GLushort Precision;  /**< number of mantissa bits */
  2535. };
  2536.  
  2537.  
  2538. /**
  2539.  * Limits for vertex and fragment programs/shaders.
  2540.  */
  2541. struct gl_program_constants
  2542. {
  2543.    /* logical limits */
  2544.    GLuint MaxInstructions;
  2545.    GLuint MaxAluInstructions;
  2546.    GLuint MaxTexInstructions;
  2547.    GLuint MaxTexIndirections;
  2548.    GLuint MaxAttribs;
  2549.    GLuint MaxTemps;
  2550.    GLuint MaxAddressRegs;
  2551.    GLuint MaxParameters;
  2552.    GLuint MaxLocalParams;
  2553.    GLuint MaxEnvParams;
  2554.    /* native/hardware limits */
  2555.    GLuint MaxNativeInstructions;
  2556.    GLuint MaxNativeAluInstructions;
  2557.    GLuint MaxNativeTexInstructions;
  2558.    GLuint MaxNativeTexIndirections;
  2559.    GLuint MaxNativeAttribs;
  2560.    GLuint MaxNativeTemps;
  2561.    GLuint MaxNativeAddressRegs;
  2562.    GLuint MaxNativeParameters;
  2563.    /* For shaders */
  2564.    GLuint MaxUniformComponents;
  2565.    /* GL_ARB_geometry_shader4 */
  2566.    GLuint MaxGeometryTextureImageUnits;
  2567.    GLuint MaxGeometryVaryingComponents;
  2568.    GLuint MaxVertexVaryingComponents;
  2569.    GLuint MaxGeometryUniformComponents;
  2570.    GLuint MaxGeometryOutputVertices;
  2571.    GLuint MaxGeometryTotalOutputComponents;
  2572.    /* ES 2.0 and GL_ARB_ES2_compatibility */
  2573.    struct gl_precision LowFloat, MediumFloat, HighFloat;
  2574.    struct gl_precision LowInt, MediumInt, HighInt;
  2575. };
  2576.  
  2577.  
  2578. /**
  2579.  * Constants which may be overridden by device driver during context creation
  2580.  * but are never changed after that.
  2581.  */
  2582. struct gl_constants
  2583. {
  2584.    GLint MaxTextureMbytes;      /**< Max memory per image, in MB */
  2585.    GLint MaxTextureLevels;      /**< Max mipmap levels. */
  2586.    GLint Max3DTextureLevels;    /**< Max mipmap levels for 3D textures */
  2587.    GLint MaxCubeTextureLevels;  /**< Max mipmap levels for cube textures */
  2588.    GLint MaxArrayTextureLayers; /**< Max layers in array textures */
  2589.    GLint MaxTextureRectSize;    /**< Max rectangle texture size, in pixes */
  2590.    GLuint MaxTextureCoordUnits;
  2591.    GLuint MaxTextureImageUnits;
  2592.    GLuint MaxVertexTextureImageUnits;
  2593.    GLuint MaxCombinedTextureImageUnits;
  2594.    GLuint MaxTextureUnits;           /**< = MIN(CoordUnits, ImageUnits) */
  2595.    GLfloat MaxTextureMaxAnisotropy;  /**< GL_EXT_texture_filter_anisotropic */
  2596.    GLfloat MaxTextureLodBias;        /**< GL_EXT_texture_lod_bias */
  2597.  
  2598.    GLuint MaxArrayLockSize;
  2599.  
  2600.    GLint SubPixelBits;
  2601.  
  2602.    GLfloat MinPointSize, MaxPointSize;       /**< aliased */
  2603.    GLfloat MinPointSizeAA, MaxPointSizeAA;   /**< antialiased */
  2604.    GLfloat PointSizeGranularity;
  2605.    GLfloat MinLineWidth, MaxLineWidth;       /**< aliased */
  2606.    GLfloat MinLineWidthAA, MaxLineWidthAA;   /**< antialiased */
  2607.    GLfloat LineWidthGranularity;
  2608.  
  2609.    GLuint MaxColorTableSize;
  2610.  
  2611.    GLuint MaxClipPlanes;
  2612.    GLuint MaxLights;
  2613.    GLfloat MaxShininess;                     /**< GL_NV_light_max_exponent */
  2614.    GLfloat MaxSpotExponent;                  /**< GL_NV_light_max_exponent */
  2615.  
  2616.    GLuint MaxViewportWidth, MaxViewportHeight;
  2617.  
  2618.    struct gl_program_constants VertexProgram;   /**< GL_ARB_vertex_program */
  2619.    struct gl_program_constants FragmentProgram; /**< GL_ARB_fragment_program */
  2620.    struct gl_program_constants GeometryProgram;  /**< GL_ARB_geometry_shader4 */
  2621.    GLuint MaxProgramMatrices;
  2622.    GLuint MaxProgramMatrixStackDepth;
  2623.  
  2624.    /** vertex array / buffer object bounds checking */
  2625.    GLboolean CheckArrayBounds;
  2626.  
  2627.    GLuint MaxDrawBuffers;    /**< GL_ARB_draw_buffers */
  2628.  
  2629.    GLuint MaxColorAttachments;   /**< GL_EXT_framebuffer_object */
  2630.    GLuint MaxRenderbufferSize;   /**< GL_EXT_framebuffer_object */
  2631.    GLuint MaxSamples;            /**< GL_ARB_framebuffer_object */
  2632.  
  2633.    GLuint MaxVarying;  /**< Number of float[4] varying parameters */
  2634.  
  2635.    GLuint GLSLVersion;  /**< GLSL version supported (ex: 120 = 1.20) */
  2636.  
  2637.    /** Which texture units support GL_ATI_envmap_bumpmap as targets */
  2638.    GLbitfield SupportedBumpUnits;
  2639.  
  2640.    /**
  2641.     * Maximum amount of time, measured in nanseconds, that the server can wait.
  2642.     */
  2643.    GLuint64 MaxServerWaitTimeout;
  2644.  
  2645.    /** GL_EXT_provoking_vertex */
  2646.    GLboolean QuadsFollowProvokingVertexConvention;
  2647.  
  2648.    /** OpenGL version 3.0 */
  2649.    GLbitfield ContextFlags;  /**< Ex: GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */
  2650.  
  2651.    /** OpenGL version 3.2 */
  2652.    GLbitfield ProfileMask;   /**< Mask of CONTEXT_x_PROFILE_BIT */
  2653.  
  2654.    /** GL_EXT_transform_feedback */
  2655.    GLuint MaxTransformFeedbackSeparateAttribs;
  2656.    GLuint MaxTransformFeedbackSeparateComponents;
  2657.    GLuint MaxTransformFeedbackInterleavedComponents;
  2658.  
  2659.    /** GL_EXT_gpu_shader4 */
  2660.    GLint MinProgramTexelOffset, MaxProgramTexelOffset;
  2661. };
  2662.  
  2663.  
  2664. /**
  2665.  * Enable flag for each OpenGL extension.  Different device drivers will
  2666.  * enable different extensions at runtime.
  2667.  */
  2668. struct gl_extensions
  2669. {
  2670.    GLboolean dummy;  /* don't remove this! */
  2671.    GLboolean dummy_true;  /* Set true by _mesa_init_extensions(). */
  2672.    GLboolean dummy_false; /* Set false by _mesa_init_extensions(). */
  2673.    GLboolean ARB_ES2_compatibility;
  2674.    GLboolean ARB_blend_func_extended;
  2675.    GLboolean ARB_copy_buffer;
  2676.    GLboolean ARB_depth_buffer_float;
  2677.    GLboolean ARB_depth_clamp;
  2678.    GLboolean ARB_depth_texture;
  2679.    GLboolean ARB_draw_buffers;
  2680.    GLboolean ARB_draw_elements_base_vertex;
  2681.    GLboolean ARB_draw_instanced;
  2682.    GLboolean ARB_fragment_coord_conventions;
  2683.    GLboolean ARB_fragment_program;
  2684.    GLboolean ARB_fragment_program_shadow;
  2685.    GLboolean ARB_fragment_shader;
  2686.    GLboolean ARB_framebuffer_object;
  2687.    GLboolean ARB_explicit_attrib_location;
  2688.    GLboolean ARB_geometry_shader4;
  2689.    GLboolean ARB_half_float_pixel;
  2690.    GLboolean ARB_half_float_vertex;
  2691.    GLboolean ARB_instanced_arrays;
  2692.    GLboolean ARB_map_buffer_range;
  2693.    GLboolean ARB_multisample;
  2694.    GLboolean ARB_multitexture;
  2695.    GLboolean ARB_occlusion_query;
  2696.    GLboolean ARB_occlusion_query2;
  2697.    GLboolean ARB_point_sprite;
  2698.    GLboolean ARB_sampler_objects;
  2699.    GLboolean ARB_seamless_cube_map;
  2700.    GLboolean ARB_shader_objects;
  2701.    GLboolean ARB_shader_stencil_export;
  2702.    GLboolean ARB_shading_language_100;
  2703.    GLboolean ARB_shadow;
  2704.    GLboolean ARB_shadow_ambient;
  2705.    GLboolean ARB_sync;
  2706.    GLboolean ARB_texture_border_clamp;
  2707.    GLboolean ARB_texture_buffer_object;
  2708.    GLboolean ARB_texture_compression;
  2709.    GLboolean ARB_texture_compression_rgtc;
  2710.    GLboolean ARB_texture_cube_map;
  2711.    GLboolean ARB_texture_env_combine;
  2712.    GLboolean ARB_texture_env_crossbar;
  2713.    GLboolean ARB_texture_env_dot3;
  2714.    GLboolean ARB_texture_float;
  2715.    GLboolean ARB_texture_mirrored_repeat;
  2716.    GLboolean ARB_texture_multisample;
  2717.    GLboolean ARB_texture_non_power_of_two;
  2718.    GLboolean ARB_texture_rg;
  2719.    GLboolean ARB_texture_rgb10_a2ui;
  2720.    GLboolean ARB_timer_query;
  2721.    GLboolean ARB_transform_feedback2;
  2722.    GLboolean ARB_transpose_matrix;
  2723.    GLboolean ARB_uniform_buffer_object;
  2724.    GLboolean ARB_vertex_array_object;
  2725.    GLboolean ARB_vertex_buffer_object;
  2726.    GLboolean ARB_vertex_program;
  2727.    GLboolean ARB_vertex_shader;
  2728.    GLboolean ARB_vertex_type_2_10_10_10_rev;
  2729.    GLboolean ARB_window_pos;
  2730.    GLboolean EXT_abgr;
  2731.    GLboolean EXT_bgra;
  2732.    GLboolean EXT_blend_color;
  2733.    GLboolean EXT_blend_equation_separate;
  2734.    GLboolean EXT_blend_func_separate;
  2735.    GLboolean EXT_blend_logic_op;
  2736.    GLboolean EXT_blend_minmax;
  2737.    GLboolean EXT_blend_subtract;
  2738.    GLboolean EXT_clip_volume_hint;
  2739.    GLboolean EXT_compiled_vertex_array;
  2740.    GLboolean EXT_copy_texture;
  2741.    GLboolean EXT_depth_bounds_test;
  2742.    GLboolean EXT_draw_buffers2;
  2743.    GLboolean EXT_draw_range_elements;
  2744.    GLboolean EXT_fog_coord;
  2745.    GLboolean EXT_framebuffer_blit;
  2746.    GLboolean EXT_framebuffer_multisample;
  2747.    GLboolean EXT_framebuffer_object;
  2748.    GLboolean EXT_framebuffer_sRGB;
  2749.    GLboolean EXT_gpu_program_parameters;
  2750.    GLboolean EXT_gpu_shader4;
  2751.    GLboolean EXT_multi_draw_arrays;
  2752.    GLboolean EXT_paletted_texture;
  2753.    GLboolean EXT_packed_depth_stencil;
  2754.    GLboolean EXT_packed_float;
  2755.    GLboolean EXT_packed_pixels;
  2756.    GLboolean EXT_pixel_buffer_object;
  2757.    GLboolean EXT_point_parameters;
  2758.    GLboolean EXT_polygon_offset;
  2759.    GLboolean EXT_provoking_vertex;
  2760.    GLboolean EXT_rescale_normal;
  2761.    GLboolean EXT_shadow_funcs;
  2762.    GLboolean EXT_secondary_color;
  2763.    GLboolean EXT_separate_shader_objects;
  2764.    GLboolean EXT_separate_specular_color;
  2765.    GLboolean EXT_shared_texture_palette;
  2766.    GLboolean EXT_stencil_wrap;
  2767.    GLboolean EXT_stencil_two_side;
  2768.    GLboolean EXT_subtexture;
  2769.    GLboolean EXT_texture;
  2770.    GLboolean EXT_texture_object;
  2771.    GLboolean EXT_texture3D;
  2772.    GLboolean EXT_texture_array;
  2773.    GLboolean EXT_texture_compression_s3tc;
  2774.    GLboolean EXT_texture_env_add;
  2775.    GLboolean EXT_texture_env_combine;
  2776.    GLboolean EXT_texture_env_dot3;
  2777.    GLboolean EXT_texture_filter_anisotropic;
  2778.    GLboolean EXT_texture_integer;
  2779.    GLboolean EXT_texture_lod_bias;
  2780.    GLboolean EXT_texture_mirror_clamp;
  2781.    GLboolean EXT_texture_shared_exponent;
  2782.    GLboolean EXT_texture_sRGB;
  2783.    GLboolean EXT_texture_swizzle;
  2784.    GLboolean EXT_transform_feedback;
  2785.    GLboolean EXT_timer_query;
  2786.    GLboolean EXT_vertex_array;
  2787.    GLboolean EXT_vertex_array_bgra;
  2788.    GLboolean EXT_vertex_array_set;
  2789.    GLboolean OES_standard_derivatives;
  2790.    /* vendor extensions */
  2791.    GLboolean APPLE_client_storage;
  2792.    GLboolean APPLE_packed_pixels;
  2793.    GLboolean APPLE_vertex_array_object;
  2794.    GLboolean APPLE_object_purgeable;
  2795.    GLboolean ATI_envmap_bumpmap;
  2796.    GLboolean ATI_texture_mirror_once;
  2797.    GLboolean ATI_texture_env_combine3;
  2798.    GLboolean ATI_fragment_shader;
  2799.    GLboolean ATI_separate_stencil;
  2800.    GLboolean IBM_rasterpos_clip;
  2801.    GLboolean IBM_multimode_draw_arrays;
  2802.    GLboolean MESA_pack_invert;
  2803.    GLboolean MESA_resize_buffers;
  2804.    GLboolean MESA_ycbcr_texture;
  2805.    GLboolean MESA_texture_array;
  2806.    GLboolean MESA_texture_signed_rgba;
  2807.    GLboolean NV_blend_square;
  2808.    GLboolean NV_conditional_render;
  2809.    GLboolean NV_fragment_program;
  2810.    GLboolean NV_fragment_program_option;
  2811.    GLboolean NV_light_max_exponent;
  2812.    GLboolean NV_point_sprite;
  2813.    GLboolean NV_primitive_restart;
  2814.    GLboolean NV_texgen_reflection;
  2815.    GLboolean NV_texture_env_combine4;
  2816.    GLboolean NV_texture_rectangle;
  2817.    GLboolean NV_vertex_program;
  2818.    GLboolean NV_vertex_program1_1;
  2819.    GLboolean OES_read_format;
  2820.    GLboolean SGI_texture_color_table;
  2821.    GLboolean SGIS_generate_mipmap;
  2822.    GLboolean SGIS_texture_edge_clamp;
  2823.    GLboolean SGIS_texture_lod;
  2824.    GLboolean TDFX_texture_compression_FXT1;
  2825.    GLboolean S3_s3tc;
  2826.    GLboolean OES_EGL_image;
  2827.    GLboolean OES_draw_texture;
  2828.    GLboolean EXT_texture_format_BGRA8888;
  2829.    GLboolean extension_sentinel;
  2830.    /** The extension string */
  2831.    const GLubyte *String;
  2832.    /** Number of supported extensions */
  2833.    GLuint Count;
  2834. };
  2835.  
  2836.  
  2837. /**
  2838.  * A stack of matrices (projection, modelview, color, texture, etc).
  2839.  */
  2840. struct gl_matrix_stack
  2841. {
  2842.    GLmatrix *Top;      /**< points into Stack */
  2843.    GLmatrix *Stack;    /**< array [MaxDepth] of GLmatrix */
  2844.    GLuint Depth;       /**< 0 <= Depth < MaxDepth */
  2845.    GLuint MaxDepth;    /**< size of Stack[] array */
  2846.    GLuint DirtyFlag;   /**< _NEW_MODELVIEW or _NEW_PROJECTION, for example */
  2847. };
  2848.  
  2849.  
  2850. /**
  2851.  * \name Bits for image transfer operations
  2852.  * \sa __struct gl_contextRec::ImageTransferState.
  2853.  */
  2854. /*@{*/
  2855. #define IMAGE_SCALE_BIAS_BIT                      0x1
  2856. #define IMAGE_SHIFT_OFFSET_BIT                    0x2
  2857. #define IMAGE_MAP_COLOR_BIT                       0x4
  2858. #define IMAGE_CLAMP_BIT                           0x800
  2859.  
  2860.  
  2861. /** Pixel Transfer ops */
  2862. #define IMAGE_BITS (IMAGE_SCALE_BIAS_BIT |                      \
  2863.                     IMAGE_SHIFT_OFFSET_BIT |                    \
  2864.                     IMAGE_MAP_COLOR_BIT)
  2865.  
  2866. /**
  2867.  * \name Bits to indicate what state has changed.
  2868.  *
  2869.  * 4 unused flags.
  2870.  */
  2871. /*@{*/
  2872. #define _NEW_MODELVIEW          0x1        /**< __struct gl_contextRec::ModelView */
  2873. #define _NEW_PROJECTION         0x2        /**< __struct gl_contextRec::Projection */
  2874. #define _NEW_TEXTURE_MATRIX     0x4        /**< __struct gl_contextRec::TextureMatrix */
  2875. #define _NEW_ACCUM              0x10       /**< __struct gl_contextRec::Accum */
  2876. #define _NEW_COLOR              0x20       /**< __struct gl_contextRec::Color */
  2877. #define _NEW_DEPTH              0x40       /**< __struct gl_contextRec::Depth */
  2878. #define _NEW_EVAL               0x80       /**< __struct gl_contextRec::Eval, __struct gl_contextRec::EvalMap */
  2879. #define _NEW_FOG                0x100      /**< __struct gl_contextRec::Fog */
  2880. #define _NEW_HINT               0x200      /**< __struct gl_contextRec::Hint */
  2881. #define _NEW_LIGHT              0x400      /**< __struct gl_contextRec::Light */
  2882. #define _NEW_LINE               0x800      /**< __struct gl_contextRec::Line */
  2883. #define _NEW_PIXEL              0x1000     /**< __struct gl_contextRec::Pixel */
  2884. #define _NEW_POINT              0x2000     /**< __struct gl_contextRec::Point */
  2885. #define _NEW_POLYGON            0x4000     /**< __struct gl_contextRec::Polygon */
  2886. #define _NEW_POLYGONSTIPPLE     0x8000     /**< __struct gl_contextRec::PolygonStipple */
  2887. #define _NEW_SCISSOR            0x10000    /**< __struct gl_contextRec::Scissor */
  2888. #define _NEW_STENCIL            0x20000    /**< __struct gl_contextRec::Stencil */
  2889. #define _NEW_TEXTURE            0x40000    /**< __struct gl_contextRec::Texture */
  2890. #define _NEW_TRANSFORM          0x80000    /**< __struct gl_contextRec::Transform */
  2891. #define _NEW_VIEWPORT           0x100000   /**< __struct gl_contextRec::Viewport */
  2892. #define _NEW_PACKUNPACK         0x200000   /**< __struct gl_contextRec::Pack, __struct gl_contextRec::Unpack */
  2893. #define _NEW_ARRAY              0x400000   /**< __struct gl_contextRec::Array */
  2894. #define _NEW_RENDERMODE         0x800000   /**< __struct gl_contextRec::RenderMode, __struct gl_contextRec::Feedback, __struct gl_contextRec::Select */
  2895. #define _NEW_BUFFERS            0x1000000  /**< __struct gl_contextRec::Visual, __struct gl_contextRec::DrawBuffer, */
  2896. #define _NEW_MULTISAMPLE        0x2000000  /**< __struct gl_contextRec::Multisample */
  2897. #define _NEW_TRACK_MATRIX       0x4000000  /**< __struct gl_contextRec::VertexProgram */
  2898. #define _NEW_PROGRAM            0x8000000  /**< __struct gl_contextRec::VertexProgram */
  2899. #define _NEW_CURRENT_ATTRIB     0x10000000  /**< __struct gl_contextRec::Current */
  2900. #define _NEW_PROGRAM_CONSTANTS  0x20000000
  2901. #define _NEW_BUFFER_OBJECT      0x40000000
  2902. #define _NEW_ALL ~0
  2903. /*@}*/
  2904.  
  2905.  
  2906. /**
  2907.  * \name Bits to track array state changes
  2908.  *
  2909.  * Also used to summarize array enabled.
  2910.  */
  2911. /*@{*/
  2912. #define _NEW_ARRAY_VERTEX           VERT_BIT_POS
  2913. #define _NEW_ARRAY_WEIGHT           VERT_BIT_WEIGHT
  2914. #define _NEW_ARRAY_NORMAL           VERT_BIT_NORMAL
  2915. #define _NEW_ARRAY_COLOR0           VERT_BIT_COLOR0
  2916. #define _NEW_ARRAY_COLOR1           VERT_BIT_COLOR1
  2917. #define _NEW_ARRAY_FOGCOORD         VERT_BIT_FOG
  2918. #define _NEW_ARRAY_INDEX            VERT_BIT_COLOR_INDEX
  2919. #define _NEW_ARRAY_EDGEFLAG         VERT_BIT_EDGEFLAG
  2920. #define _NEW_ARRAY_POINT_SIZE       VERT_BIT_COLOR_INDEX  /* aliased */
  2921. #define _NEW_ARRAY_TEXCOORD_0       VERT_BIT_TEX0
  2922. #define _NEW_ARRAY_TEXCOORD_1       VERT_BIT_TEX1
  2923. #define _NEW_ARRAY_TEXCOORD_2       VERT_BIT_TEX2
  2924. #define _NEW_ARRAY_TEXCOORD_3       VERT_BIT_TEX3
  2925. #define _NEW_ARRAY_TEXCOORD_4       VERT_BIT_TEX4
  2926. #define _NEW_ARRAY_TEXCOORD_5       VERT_BIT_TEX5
  2927. #define _NEW_ARRAY_TEXCOORD_6       VERT_BIT_TEX6
  2928. #define _NEW_ARRAY_TEXCOORD_7       VERT_BIT_TEX7
  2929. #define _NEW_ARRAY_ATTRIB_0         VERT_BIT_GENERIC0  /* start at bit 16 */
  2930. #define _NEW_ARRAY_ALL              0xffffffff
  2931.  
  2932.  
  2933. #define _NEW_ARRAY_TEXCOORD(i) (_NEW_ARRAY_TEXCOORD_0 << (i))
  2934. #define _NEW_ARRAY_ATTRIB(i) (_NEW_ARRAY_ATTRIB_0 << (i))
  2935. /*@}*/
  2936.  
  2937.  
  2938.  
  2939. /**
  2940.  * \name A bunch of flags that we think might be useful to drivers.
  2941.  *
  2942.  * Set in the __struct gl_contextRec::_TriangleCaps bitfield.
  2943.  */
  2944. /*@{*/
  2945. #define DD_FLATSHADE                0x1
  2946. #define DD_SEPARATE_SPECULAR        0x2
  2947. #define DD_TRI_CULL_FRONT_BACK      0x4 /* special case on some hw */
  2948. #define DD_TRI_LIGHT_TWOSIDE        0x8
  2949. #define DD_TRI_UNFILLED             0x10
  2950. #define DD_TRI_SMOOTH               0x20
  2951. #define DD_TRI_STIPPLE              0x40
  2952. #define DD_TRI_OFFSET               0x80
  2953. #define DD_LINE_SMOOTH              0x100
  2954. #define DD_LINE_STIPPLE             0x200
  2955. #define DD_POINT_SMOOTH             0x400
  2956. #define DD_POINT_ATTEN              0x800
  2957. #define DD_TRI_TWOSTENCIL           0x1000
  2958. /*@}*/
  2959.  
  2960.  
  2961. /**
  2962.  * \name Define the state changes under which each of these bits might change
  2963.  */
  2964. /*@{*/
  2965. #define _DD_NEW_FLATSHADE                _NEW_LIGHT
  2966. #define _DD_NEW_SEPARATE_SPECULAR        (_NEW_LIGHT | _NEW_FOG | _NEW_PROGRAM)
  2967. #define _DD_NEW_TRI_CULL_FRONT_BACK      _NEW_POLYGON
  2968. #define _DD_NEW_TRI_LIGHT_TWOSIDE        _NEW_LIGHT
  2969. #define _DD_NEW_TRI_UNFILLED             _NEW_POLYGON
  2970. #define _DD_NEW_TRI_SMOOTH               _NEW_POLYGON
  2971. #define _DD_NEW_TRI_STIPPLE              _NEW_POLYGON
  2972. #define _DD_NEW_TRI_OFFSET               _NEW_POLYGON
  2973. #define _DD_NEW_LINE_SMOOTH              _NEW_LINE
  2974. #define _DD_NEW_LINE_STIPPLE             _NEW_LINE
  2975. #define _DD_NEW_LINE_WIDTH               _NEW_LINE
  2976. #define _DD_NEW_POINT_SMOOTH             _NEW_POINT
  2977. #define _DD_NEW_POINT_SIZE               _NEW_POINT
  2978. #define _DD_NEW_POINT_ATTEN              _NEW_POINT
  2979. /*@}*/
  2980.  
  2981.  
  2982. /**
  2983.  * Composite state flags
  2984.  */
  2985. /*@{*/
  2986. #define _MESA_NEW_NEED_EYE_COORDS         (_NEW_LIGHT |         \
  2987.                                            _NEW_TEXTURE |       \
  2988.                                            _NEW_POINT |         \
  2989.                                            _NEW_PROGRAM |       \
  2990.                                            _NEW_MODELVIEW)
  2991.  
  2992. #define _MESA_NEW_NEED_NORMALS            (_NEW_LIGHT |         \
  2993.                                            _NEW_TEXTURE)
  2994.  
  2995. #define _MESA_NEW_TRANSFER_STATE          (_NEW_PIXEL)
  2996. /*@}*/
  2997.  
  2998.  
  2999.  
  3000.  
  3001. /* This has to be included here. */
  3002. #include "dd.h"
  3003.  
  3004.  
  3005. /**
  3006.  * Display list flags.
  3007.  * Strictly this is a tnl-private concept, but it doesn't seem
  3008.  * worthwhile adding a tnl private structure just to hold this one bit
  3009.  * of information:
  3010.  */
  3011. #define DLIST_DANGLING_REFS     0x1
  3012.  
  3013.  
  3014. /** Opaque declaration of display list payload data type */
  3015. union gl_dlist_node;
  3016.  
  3017.  
  3018. /**
  3019.  * Provide a location where information about a display list can be
  3020.  * collected.  Could be extended with driverPrivate structures,
  3021.  * etc. in the future.
  3022.  */
  3023. struct gl_display_list
  3024. {
  3025.    GLuint Name;
  3026.    GLbitfield Flags;  /**< DLIST_x flags */
  3027.    /** The dlist commands are in a linked list of nodes */
  3028.    union gl_dlist_node *Head;
  3029. };
  3030.  
  3031.  
  3032. /**
  3033.  * State used during display list compilation and execution.
  3034.  */
  3035. struct gl_dlist_state
  3036. {
  3037.    GLuint CallDepth;            /**< Current recursion calling depth */
  3038.  
  3039.    struct gl_display_list *CurrentList; /**< List currently being compiled */
  3040.    union gl_dlist_node *CurrentBlock; /**< Pointer to current block of nodes */
  3041.    GLuint CurrentPos;           /**< Index into current block of nodes */
  3042.  
  3043.    GLvertexformat ListVtxfmt;
  3044.  
  3045.    GLubyte ActiveAttribSize[VERT_ATTRIB_MAX];
  3046.    GLfloat CurrentAttrib[VERT_ATTRIB_MAX][4];
  3047.  
  3048.    GLubyte ActiveMaterialSize[MAT_ATTRIB_MAX];
  3049.    GLfloat CurrentMaterial[MAT_ATTRIB_MAX][4];
  3050.  
  3051.    GLubyte ActiveIndex;
  3052.    GLfloat CurrentIndex;
  3053.  
  3054.    GLubyte ActiveEdgeFlag;
  3055.    GLboolean CurrentEdgeFlag;
  3056.  
  3057.    struct {
  3058.       /* State known to have been set by the currently-compiling display
  3059.        * list.  Used to eliminate some redundant state changes.
  3060.        */
  3061.       GLenum ShadeModel;
  3062.    } Current;
  3063. };
  3064.  
  3065. /**
  3066.  * Enum for the OpenGL APIs we know about and may support.
  3067.  */
  3068. typedef enum {
  3069.    API_OPENGL,
  3070.    API_OPENGLES,
  3071.    API_OPENGLES2
  3072. } gl_api;
  3073.  
  3074. /**
  3075.  * Mesa rendering context.
  3076.  *
  3077.  * This is the central context data structure for Mesa.  Almost all
  3078.  * OpenGL state is contained in this structure.
  3079.  * Think of this as a base class from which device drivers will derive
  3080.  * sub classes.
  3081.  *
  3082.  * The struct gl_context typedef names this structure.
  3083.  */
  3084. struct gl_context
  3085. {
  3086.    /** State possibly shared with other contexts in the address space */
  3087.    struct gl_shared_state *Shared;
  3088.  
  3089.    /** \name API function pointer tables */
  3090.    /*@{*/
  3091.    gl_api API;
  3092.    struct _glapi_table *Save;   /**< Display list save functions */
  3093.    struct _glapi_table *Exec;   /**< Execute functions */
  3094.    struct _glapi_table *CurrentDispatch;  /**< == Save or Exec !! */
  3095.    /*@}*/
  3096.  
  3097.    struct gl_config Visual;
  3098.    struct gl_framebuffer *DrawBuffer;   /**< buffer for writing */
  3099.    struct gl_framebuffer *ReadBuffer;   /**< buffer for reading */
  3100.    struct gl_framebuffer *WinSysDrawBuffer;  /**< set with MakeCurrent */
  3101.    struct gl_framebuffer *WinSysReadBuffer;  /**< set with MakeCurrent */
  3102.  
  3103.    /**
  3104.     * Device driver function pointer table
  3105.     */
  3106.    struct dd_function_table Driver;
  3107.  
  3108.    void *DriverCtx;     /**< Points to device driver context/state */
  3109.  
  3110.    /** Core/Driver constants */
  3111.    struct gl_constants Const;
  3112.  
  3113.    /** \name The various 4x4 matrix stacks */
  3114.    /*@{*/
  3115.    struct gl_matrix_stack ModelviewMatrixStack;
  3116.    struct gl_matrix_stack ProjectionMatrixStack;
  3117.    struct gl_matrix_stack TextureMatrixStack[MAX_TEXTURE_UNITS];
  3118.    struct gl_matrix_stack ProgramMatrixStack[MAX_PROGRAM_MATRICES];
  3119.    struct gl_matrix_stack *CurrentStack; /**< Points to one of the above stacks */
  3120.    /*@}*/
  3121.  
  3122.    /** Combined modelview and projection matrix */
  3123.    GLmatrix _ModelProjectMatrix;
  3124.  
  3125.    /** \name Display lists */
  3126.    struct gl_dlist_state ListState;
  3127.  
  3128.    GLboolean ExecuteFlag;       /**< Execute GL commands? */
  3129.    GLboolean CompileFlag;       /**< Compile GL commands into display list? */
  3130.  
  3131.    /** Extension information */
  3132.    struct gl_extensions Extensions;
  3133.  
  3134.    /** Version info */
  3135.    GLuint VersionMajor, VersionMinor;
  3136.    char *VersionString;
  3137.  
  3138.    /** \name State attribute stack (for glPush/PopAttrib) */
  3139.    /*@{*/
  3140.    GLuint AttribStackDepth;
  3141.    struct gl_attrib_node *AttribStack[MAX_ATTRIB_STACK_DEPTH];
  3142.    /*@}*/
  3143.  
  3144.    /** \name Renderer attribute groups
  3145.     *
  3146.     * We define a struct for each attribute group to make pushing and popping
  3147.     * attributes easy.  Also it's a good organization.
  3148.     */
  3149.    /*@{*/
  3150.    struct gl_accum_attrib       Accum;          /**< Accum buffer attributes */
  3151.    struct gl_colorbuffer_attrib Color;          /**< Color buffer attributes */
  3152.    struct gl_current_attrib     Current;        /**< Current attributes */
  3153.    struct gl_depthbuffer_attrib Depth;          /**< Depth buffer attributes */
  3154.    struct gl_eval_attrib        Eval;           /**< Eval attributes */
  3155.    struct gl_fog_attrib         Fog;            /**< Fog attributes */
  3156.    struct gl_hint_attrib        Hint;           /**< Hint attributes */
  3157.    struct gl_light_attrib       Light;          /**< Light attributes */
  3158.    struct gl_line_attrib        Line;           /**< Line attributes */
  3159.    struct gl_list_attrib        List;           /**< List attributes */
  3160.    struct gl_multisample_attrib Multisample;
  3161.    struct gl_pixel_attrib       Pixel;          /**< Pixel attributes */
  3162.    struct gl_point_attrib       Point;          /**< Point attributes */
  3163.    struct gl_polygon_attrib     Polygon;        /**< Polygon attributes */
  3164.    GLuint PolygonStipple[32];                   /**< Polygon stipple */
  3165.    struct gl_scissor_attrib     Scissor;        /**< Scissor attributes */
  3166.    struct gl_stencil_attrib     Stencil;        /**< Stencil buffer attributes */
  3167.    struct gl_texture_attrib     Texture;        /**< Texture attributes */
  3168.    struct gl_transform_attrib   Transform;      /**< Transformation attributes */
  3169.    struct gl_viewport_attrib    Viewport;       /**< Viewport attributes */
  3170.    /*@}*/
  3171.  
  3172.    /** \name Client attribute stack */
  3173.    /*@{*/
  3174.    GLuint ClientAttribStackDepth;
  3175.    struct gl_attrib_node *ClientAttribStack[MAX_CLIENT_ATTRIB_STACK_DEPTH];
  3176.    /*@}*/
  3177.  
  3178.    /** \name Client attribute groups */
  3179.    /*@{*/
  3180.    struct gl_array_attrib       Array;  /**< Vertex arrays */
  3181.    struct gl_pixelstore_attrib  Pack;   /**< Pixel packing */
  3182.    struct gl_pixelstore_attrib  Unpack; /**< Pixel unpacking */
  3183.    struct gl_pixelstore_attrib  DefaultPacking; /**< Default params */
  3184.    /*@}*/
  3185.  
  3186.    /** \name Other assorted state (not pushed/popped on attribute stack) */
  3187.    /*@{*/
  3188.    struct gl_pixelmaps          PixelMaps;
  3189.  
  3190.    struct gl_evaluators EvalMap;   /**< All evaluators */
  3191.    struct gl_feedback   Feedback;  /**< Feedback */
  3192.    struct gl_selection  Select;    /**< Selection */
  3193.  
  3194.    struct gl_program_state Program;  /**< general program state */
  3195.    struct gl_vertex_program_state VertexProgram;
  3196.    struct gl_fragment_program_state FragmentProgram;
  3197.    struct gl_geometry_program_state GeometryProgram;
  3198.    struct gl_ati_fragment_shader_state ATIFragmentShader;
  3199.  
  3200.    struct gl_shader_state Shader; /**< GLSL shader object state */
  3201.    struct gl_shader_compiler_options ShaderCompilerOptions[MESA_SHADER_TYPES];
  3202.  
  3203.    struct gl_query_state Query;  /**< occlusion, timer queries */
  3204.  
  3205.    struct gl_transform_feedback TransformFeedback;
  3206.  
  3207.    struct gl_buffer_object *CopyReadBuffer; /**< GL_ARB_copy_buffer */
  3208.    struct gl_buffer_object *CopyWriteBuffer; /**< GL_ARB_copy_buffer */
  3209.    /*@}*/
  3210.  
  3211.    struct gl_meta_state *Meta;  /**< for "meta" operations */
  3212.  
  3213.    /* GL_EXT_framebuffer_object */
  3214.    struct gl_renderbuffer *CurrentRenderbuffer;
  3215.  
  3216.    GLenum ErrorValue;        /**< Last error code */
  3217.  
  3218.    /**
  3219.     * Recognize and silence repeated error debug messages in buggy apps.
  3220.     */
  3221.    const char *ErrorDebugFmtString;
  3222.    GLuint ErrorDebugCount;
  3223.  
  3224.    GLenum RenderMode;        /**< either GL_RENDER, GL_SELECT, GL_FEEDBACK */
  3225.    GLbitfield NewState;      /**< bitwise-or of _NEW_* flags */
  3226.  
  3227.    GLboolean ViewportInitialized;  /**< has viewport size been initialized? */
  3228.  
  3229.    GLbitfield varying_vp_inputs;  /**< mask of VERT_BIT_* flags */
  3230.  
  3231.    /** \name Derived state */
  3232.    /*@{*/
  3233.    /** Bitwise-or of DD_* flags.  Note that this bitfield may be used before
  3234.     * state validation so they need to always be current.
  3235.     */
  3236.    GLbitfield _TriangleCaps;
  3237.    GLbitfield _ImageTransferState;/**< bitwise-or of IMAGE_*_BIT flags */
  3238.    GLfloat _EyeZDir[3];
  3239.    GLfloat _ModelViewInvScale;
  3240.    GLboolean _NeedEyeCoords;
  3241.    GLboolean _ForceEyeCoords;
  3242.  
  3243.    GLuint TextureStateTimestamp; /**< detect changes to shared state */
  3244.  
  3245.    struct gl_shine_tab *_ShineTable[2]; /**< Active shine tables */
  3246.    struct gl_shine_tab *_ShineTabList;  /**< MRU list of inactive shine tables */
  3247.    /**@}*/
  3248.  
  3249.    struct gl_list_extensions *ListExt; /**< driver dlist extensions */
  3250.  
  3251.    /** \name For debugging/development only */
  3252.    /*@{*/
  3253.    GLboolean FirstTimeCurrent;
  3254.    /*@}*/
  3255.  
  3256.    /** Dither disable via MESA_NO_DITHER env var */
  3257.    GLboolean NoDither;
  3258.  
  3259.    /** software compression/decompression supported or not */
  3260.    GLboolean Mesa_DXTn;
  3261.  
  3262.    /**
  3263.     * Use dp4 (rather than mul/mad) instructions for position
  3264.     * transformation?
  3265.     */
  3266.    GLboolean mvp_with_dp4;
  3267.  
  3268.    /**
  3269.     * \name Hooks for module contexts.
  3270.     *
  3271.     * These will eventually live in the driver or elsewhere.
  3272.     */
  3273.    /*@{*/
  3274.    void *swrast_context;
  3275.    void *swsetup_context;
  3276.    void *swtnl_context;
  3277.    void *swtnl_im;
  3278.    struct st_context *st;
  3279.    void *aelt_context;
  3280.    /*@}*/
  3281. };
  3282.  
  3283.  
  3284. /** The string names for GL_POINT, GL_LINE_LOOP, etc */
  3285. extern const char *_mesa_prim_name[GL_POLYGON+4];
  3286.  
  3287.  
  3288. #ifdef DEBUG
  3289. extern int MESA_VERBOSE;
  3290. extern int MESA_DEBUG_FLAGS;
  3291. # define MESA_FUNCTION __FUNCTION__
  3292. #else
  3293. # define MESA_VERBOSE 0
  3294. # define MESA_DEBUG_FLAGS 0
  3295. # define MESA_FUNCTION "a function"
  3296. # ifndef NDEBUG
  3297. #  define NDEBUG
  3298. # endif
  3299. #endif
  3300.  
  3301.  
  3302. /** The MESA_VERBOSE var is a bitmask of these flags */
  3303. enum _verbose
  3304. {
  3305.    VERBOSE_VARRAY               = 0x0001,
  3306.    VERBOSE_TEXTURE              = 0x0002,
  3307.    VERBOSE_MATERIAL             = 0x0004,
  3308.    VERBOSE_PIPELINE             = 0x0008,
  3309.    VERBOSE_DRIVER               = 0x0010,
  3310.    VERBOSE_STATE                = 0x0020,
  3311.    VERBOSE_API                  = 0x0040,
  3312.    VERBOSE_DISPLAY_LIST         = 0x0100,
  3313.    VERBOSE_LIGHTING             = 0x0200,
  3314.    VERBOSE_PRIMS                = 0x0400,
  3315.    VERBOSE_VERTS                = 0x0800,
  3316.    VERBOSE_DISASSEM             = 0x1000,
  3317.    VERBOSE_DRAW                 = 0x2000,
  3318.    VERBOSE_SWAPBUFFERS          = 0x4000
  3319. };
  3320.  
  3321.  
  3322. /** The MESA_DEBUG_FLAGS var is a bitmask of these flags */
  3323. enum _debug
  3324. {
  3325.    DEBUG_ALWAYS_FLUSH           = 0x1
  3326. };
  3327.  
  3328.  
  3329.  
  3330. #endif /* MTYPES_H */
  3331.