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