src/mesa/main/mtypes.h

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