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/*@{*/ 84typedef 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/*@{*/ 109struct _mesa_HashTable; 110struct gl_attrib_node; 111struct gl_list_extensions; 112struct gl_meta_state; 113struct gl_pixelstore_attrib; 114struct gl_program_cache; 115struct gl_texture_format; 116struct gl_texture_image; 117struct gl_texture_object; 118struct gl_context; 119struct 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 */ 128typedef 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 */ 145typedef 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 */ 229typedef 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 */ 257typedef 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/*@{*/ 299typedef 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 */ 327typedef 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 */ 384typedef 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 */ 397typedef 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 */ 467struct 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 */ 527struct 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 */ 610struct 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 */ 622struct 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 */ 666struct 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 */ 679struct gl_material 680{ 681 GLfloat Attrib[MAT_ATTRIB_MAX][4]; 682}; 683 684 685/** 686 * Accumulation buffer attribute group (GL_ACCUM_BUFFER_BIT) 687 */ 688struct 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 */ 697struct 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 */ 750struct 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 */ 778struct 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 */ 792struct 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 */ 837struct 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 */ 857struct 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 */ 884struct 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 */ 922struct 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 */ 935struct gl_list_attrib 936{ 937 GLuint ListBase; 938}; 939 940 941/** 942 * Multisample attribute group (GL_MULTISAMPLE_BIT). 943 */ 944struct 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 */ 959struct 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 */ 970struct 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 */ 988struct 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 */ 1024struct 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 */ 1042struct 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 */ 1063struct 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 */ 1087struct 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 */ 1111typedef 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 */ 1191typedef 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 */ 1200typedef void (*FetchTexelFuncF)( const struct gl_texture_image *texImage, 1201 GLint col, GLint row, GLint img, 1202 GLfloat *texelOut ); 1203 1204 1205typedef 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 */ 1214struct 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 */ 1264typedef 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 */ 1342struct 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 */ 1362struct 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 */ 1376struct 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 */ 1430struct 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 */ 1464struct 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 */ 1518struct 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 */ 1537struct 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 */ 1604struct 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 */ 1634struct 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 */ 1647struct 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 */ 1664struct 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 */ 1675struct 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 */ 1688struct 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 */ 1735typedef 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 */ 1756struct prog_instruction; 1757struct gl_program_parameter_list; 1758struct gl_uniform_list; 1759 1760 1761/** 1762 * Base class for any kind of program object 1763 */ 1764struct 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 */ 1830struct 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 */ 1839struct 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 */ 1851struct 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 */ 1864struct 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 */ 1874struct 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 */ 1910struct 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 */ 1930struct 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 1961struct atifs_instruction; 1962struct atifs_setupinst; 1963 1964/** 1965 * ATI fragment shader 1966 */ 1967struct 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 */ 1988struct 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 */ 2001struct 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 */ 2014struct 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 */ 2035struct 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 */ 2050struct 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 */ 2062struct 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 */ 2095struct 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 */ 2167struct 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 */ 2195struct 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 */ 2230struct 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 */ 2251struct 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 */ 2439struct 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 */ 2540struct 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 */ 2578struct 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 */ 2664struct 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 */ 3006union 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 */ 3014struct 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 */ 3059typedef 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 */ 3075struct 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 */ 3276extern const char *_mesa_prim_name[GL_POLYGON+4]; 3277 3278 3279#ifdef DEBUG 3280extern int MESA_VERBOSE; 3281extern 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 */ 3294enum _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 */ 3314enum _debug 3315{ 3316 DEBUG_ALWAYS_FLUSH = 0x1 3317}; 3318 3319 3320 3321#endif /* MTYPES_H */ 3322