src/mesa/main/mtypes.h

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