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