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