src/mesa/main/mtypes.h

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