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