mtypes.h revision 8dc79ae7d73cf6711c2182ff9a5d37ef6c989d23
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 47extern "C" { 48#endif 49 50 51/** 52 * \name 64-bit extension of GLbitfield. 53 */ 54/*@{*/ 55typedef 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/*@{*/ 71struct _mesa_HashTable; 72struct gl_attrib_node; 73struct gl_list_extensions; 74struct gl_meta_state; 75struct gl_program_cache; 76struct gl_texture_object; 77struct gl_context; 78struct st_context; 79struct gl_uniform_storage; 80struct prog_instruction; 81struct 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 */ 99typedef 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 */ 216typedef 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 */ 247typedef 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 */ 288typedef 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 */ 319typedef 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 */ 351static 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 */ 371static 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 */ 420typedef 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 */ 441typedef 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 */ 511struct 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 */ 635struct 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 */ 655struct 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 */ 695struct 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 */ 708struct 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 */ 718union 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 */ 729struct 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 */ 804struct 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 */ 832struct 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 */ 846struct 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 */ 891struct 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 */ 913struct 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 */ 930struct 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 */ 967struct 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 */ 980struct gl_list_attrib 981{ 982 GLuint ListBase; 983}; 984 985 986/** 987 * Multisample attribute group (GL_MULTISAMPLE_BIT). 988 */ 989struct 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 */ 1004struct gl_pixelmap 1005{ 1006 GLint Size; 1007 GLfloat Map[MAX_PIXEL_MAP_TABLE]; 1008}; 1009 1010 1011/** 1012 * Collection of all pixelmaps 1013 */ 1014struct 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 */ 1032struct 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 */ 1064struct 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 */ 1082struct 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 */ 1103struct 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 */ 1127struct 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 */ 1151typedef 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 */ 1187struct 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 MaxLog2; /**< = MAX(WidthLog2, HeightLog2) */ 1209 1210 struct gl_texture_object *TexObject; /**< Pointer back to parent object */ 1211 GLuint Level; /**< Which mipmap level am I? */ 1212 /** Cube map face: index into gl_texture_object::Image[] array */ 1213 GLuint Face; 1214}; 1215 1216 1217/** 1218 * Indexes for cube map faces. 1219 */ 1220typedef enum 1221{ 1222 FACE_POS_X = 0, 1223 FACE_NEG_X = 1, 1224 FACE_POS_Y = 2, 1225 FACE_NEG_Y = 3, 1226 FACE_POS_Z = 4, 1227 FACE_NEG_Z = 5, 1228 MAX_FACES = 6 1229} gl_face_index; 1230 1231 1232/** 1233 * Sampler object state. These objects are new with GL_ARB_sampler_objects 1234 * and OpenGL 3.3. Legacy texture objects also contain a sampler object. 1235 */ 1236struct gl_sampler_object 1237{ 1238 GLuint Name; 1239 GLint RefCount; 1240 1241 GLenum WrapS; /**< S-axis texture image wrap mode */ 1242 GLenum WrapT; /**< T-axis texture image wrap mode */ 1243 GLenum WrapR; /**< R-axis texture image wrap mode */ 1244 GLenum MinFilter; /**< minification filter */ 1245 GLenum MagFilter; /**< magnification filter */ 1246 union gl_color_union BorderColor; /**< Interpreted according to texture format */ 1247 GLfloat MinLod; /**< min lambda, OpenGL 1.2 */ 1248 GLfloat MaxLod; /**< max lambda, OpenGL 1.2 */ 1249 GLfloat LodBias; /**< OpenGL 1.4 */ 1250 GLfloat MaxAnisotropy; /**< GL_EXT_texture_filter_anisotropic */ 1251 GLenum CompareMode; /**< GL_ARB_shadow */ 1252 GLenum CompareFunc; /**< GL_ARB_shadow */ 1253 GLenum sRGBDecode; /**< GL_DECODE_EXT or GL_SKIP_DECODE_EXT */ 1254 GLboolean CubeMapSeamless; /**< GL_AMD_seamless_cubemap_per_texture */ 1255}; 1256 1257 1258/** 1259 * Texture object state. Contains the array of mipmap images, border color, 1260 * wrap modes, filter modes, and shadow/texcompare state. 1261 */ 1262struct gl_texture_object 1263{ 1264 _glthread_Mutex Mutex; /**< for thread safety */ 1265 GLint RefCount; /**< reference count */ 1266 GLuint Name; /**< the user-visible texture object ID */ 1267 GLenum Target; /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */ 1268 1269 struct gl_sampler_object Sampler; 1270 1271 GLenum DepthMode; /**< GL_ARB_depth_texture */ 1272 1273 GLfloat Priority; /**< in [0,1] */ 1274 GLint BaseLevel; /**< min mipmap level, OpenGL 1.2 */ 1275 GLint MaxLevel; /**< max mipmap level, OpenGL 1.2 */ 1276 GLint _MaxLevel; /**< actual max mipmap level (q in the spec) */ 1277 GLfloat _MaxLambda; /**< = _MaxLevel - BaseLevel (q - b in spec) */ 1278 GLint CropRect[4]; /**< GL_OES_draw_texture */ 1279 GLenum Swizzle[4]; /**< GL_EXT_texture_swizzle */ 1280 GLuint _Swizzle; /**< same as Swizzle, but SWIZZLE_* format */ 1281 GLboolean GenerateMipmap; /**< GL_SGIS_generate_mipmap */ 1282 GLboolean _BaseComplete; /**< Is the base texture level valid? */ 1283 GLboolean _MipmapComplete; /**< Is the whole mipmap valid? */ 1284 GLboolean _IsIntegerFormat; /**< Does the texture store integer values? */ 1285 GLboolean _RenderToTexture; /**< Any rendering to this texture? */ 1286 GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */ 1287 GLboolean Immutable; /**< GL_ARB_texture_storage */ 1288 1289 /** Actual texture images, indexed by [cube face] and [mipmap level] */ 1290 struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS]; 1291 1292 /** GL_ARB_texture_buffer_object */ 1293 struct gl_buffer_object *BufferObject; 1294 GLenum BufferObjectFormat; 1295 /** Equivalent Mesa format for BufferObjectFormat. */ 1296 gl_format _BufferObjectFormat; 1297 1298 /** GL_OES_EGL_image_external */ 1299 GLint RequiredTextureImageUnits; 1300}; 1301 1302 1303/** Up to four combiner sources are possible with GL_NV_texture_env_combine4 */ 1304#define MAX_COMBINER_TERMS 4 1305 1306 1307/** 1308 * Texture combine environment state. 1309 */ 1310struct gl_tex_env_combine_state 1311{ 1312 GLenum ModeRGB; /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */ 1313 GLenum ModeA; /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */ 1314 /** Source terms: GL_PRIMARY_COLOR, GL_TEXTURE, etc */ 1315 GLenum SourceRGB[MAX_COMBINER_TERMS]; 1316 GLenum SourceA[MAX_COMBINER_TERMS]; 1317 /** Source operands: GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, etc */ 1318 GLenum OperandRGB[MAX_COMBINER_TERMS]; 1319 GLenum OperandA[MAX_COMBINER_TERMS]; 1320 GLuint ScaleShiftRGB; /**< 0, 1 or 2 */ 1321 GLuint ScaleShiftA; /**< 0, 1 or 2 */ 1322 GLuint _NumArgsRGB; /**< Number of inputs used for the RGB combiner */ 1323 GLuint _NumArgsA; /**< Number of inputs used for the A combiner */ 1324}; 1325 1326 1327/** 1328 * TexGenEnabled flags. 1329 */ 1330/*@{*/ 1331#define S_BIT 1 1332#define T_BIT 2 1333#define R_BIT 4 1334#define Q_BIT 8 1335#define STR_BITS (S_BIT | T_BIT | R_BIT) 1336/*@}*/ 1337 1338 1339/** 1340 * Bit flag versions of the corresponding GL_ constants. 1341 */ 1342/*@{*/ 1343#define TEXGEN_SPHERE_MAP 0x1 1344#define TEXGEN_OBJ_LINEAR 0x2 1345#define TEXGEN_EYE_LINEAR 0x4 1346#define TEXGEN_REFLECTION_MAP_NV 0x8 1347#define TEXGEN_NORMAL_MAP_NV 0x10 1348 1349#define TEXGEN_NEED_NORMALS (TEXGEN_SPHERE_MAP | \ 1350 TEXGEN_REFLECTION_MAP_NV | \ 1351 TEXGEN_NORMAL_MAP_NV) 1352#define TEXGEN_NEED_EYE_COORD (TEXGEN_SPHERE_MAP | \ 1353 TEXGEN_REFLECTION_MAP_NV | \ 1354 TEXGEN_NORMAL_MAP_NV | \ 1355 TEXGEN_EYE_LINEAR) 1356/*@}*/ 1357 1358 1359 1360/** Tex-gen enabled for texture unit? */ 1361#define ENABLE_TEXGEN(unit) (1 << (unit)) 1362 1363/** Non-identity texture matrix for texture unit? */ 1364#define ENABLE_TEXMAT(unit) (1 << (unit)) 1365 1366 1367/** 1368 * Texture coord generation state. 1369 */ 1370struct gl_texgen 1371{ 1372 GLenum Mode; /**< GL_EYE_LINEAR, GL_SPHERE_MAP, etc */ 1373 GLbitfield _ModeBit; /**< TEXGEN_x bit corresponding to Mode */ 1374 GLfloat ObjectPlane[4]; 1375 GLfloat EyePlane[4]; 1376}; 1377 1378 1379/** 1380 * Texture unit state. Contains enable flags, texture environment/function/ 1381 * combiners, texgen state, and pointers to current texture objects. 1382 */ 1383struct gl_texture_unit 1384{ 1385 GLbitfield Enabled; /**< bitmask of TEXTURE_*_BIT flags */ 1386 GLbitfield _ReallyEnabled; /**< 0 or exactly one of TEXTURE_*_BIT flags */ 1387 1388 GLenum EnvMode; /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */ 1389 GLclampf EnvColor[4]; 1390 GLfloat EnvColorUnclamped[4]; 1391 1392 struct gl_texgen GenS; 1393 struct gl_texgen GenT; 1394 struct gl_texgen GenR; 1395 struct gl_texgen GenQ; 1396 GLbitfield TexGenEnabled; /**< Bitwise-OR of [STRQ]_BIT values */ 1397 GLbitfield _GenFlags; /**< Bitwise-OR of Gen[STRQ]._ModeBit */ 1398 1399 GLfloat LodBias; /**< for biasing mipmap levels */ 1400 GLenum BumpTarget; 1401 GLfloat RotMatrix[4]; /* 2x2 matrix */ 1402 1403 /** Current sampler object (GL_ARB_sampler_objects) */ 1404 struct gl_sampler_object *Sampler; 1405 1406 /** 1407 * \name GL_EXT_texture_env_combine 1408 */ 1409 struct gl_tex_env_combine_state Combine; 1410 1411 /** 1412 * Derived state based on \c EnvMode and the \c BaseFormat of the 1413 * currently enabled texture. 1414 */ 1415 struct gl_tex_env_combine_state _EnvMode; 1416 1417 /** 1418 * Currently enabled combiner state. This will point to either 1419 * \c Combine or \c _EnvMode. 1420 */ 1421 struct gl_tex_env_combine_state *_CurrentCombine; 1422 1423 /** Current texture object pointers */ 1424 struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS]; 1425 1426 /** Points to highest priority, complete and enabled texture object */ 1427 struct gl_texture_object *_Current; 1428}; 1429 1430 1431/** 1432 * Texture attribute group (GL_TEXTURE_BIT). 1433 */ 1434struct gl_texture_attrib 1435{ 1436 GLuint CurrentUnit; /**< GL_ACTIVE_TEXTURE */ 1437 struct gl_texture_unit Unit[MAX_COMBINED_TEXTURE_IMAGE_UNITS]; 1438 1439 struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS]; 1440 1441 /** GL_ARB_texture_buffer_object */ 1442 struct gl_buffer_object *BufferObject; 1443 1444 /** GL_ARB_seamless_cubemap */ 1445 GLboolean CubeMapSeamless; 1446 1447 /** Texture units/samplers used by vertex or fragment texturing */ 1448 GLbitfield _EnabledUnits; 1449 1450 /** Texture coord units/sets used for fragment texturing */ 1451 GLbitfield _EnabledCoordUnits; 1452 1453 /** Texture coord units that have texgen enabled */ 1454 GLbitfield _TexGenEnabled; 1455 1456 /** Texture coord units that have non-identity matrices */ 1457 GLbitfield _TexMatEnabled; 1458 1459 /** Bitwise-OR of all Texture.Unit[i]._GenFlags */ 1460 GLbitfield _GenFlags; 1461}; 1462 1463 1464/** 1465 * Data structure representing a single clip plane (e.g. one of the elements 1466 * of the ctx->Transform.EyeUserPlane or ctx->Transform._ClipUserPlane array). 1467 */ 1468typedef GLfloat gl_clip_plane[4]; 1469 1470 1471/** 1472 * Transformation attribute group (GL_TRANSFORM_BIT). 1473 */ 1474struct gl_transform_attrib 1475{ 1476 GLenum MatrixMode; /**< Matrix mode */ 1477 gl_clip_plane EyeUserPlane[MAX_CLIP_PLANES]; /**< User clip planes */ 1478 gl_clip_plane _ClipUserPlane[MAX_CLIP_PLANES]; /**< derived */ 1479 GLbitfield ClipPlanesEnabled; /**< on/off bitmask */ 1480 GLboolean Normalize; /**< Normalize all normals? */ 1481 GLboolean RescaleNormals; /**< GL_EXT_rescale_normal */ 1482 GLboolean RasterPositionUnclipped; /**< GL_IBM_rasterpos_clip */ 1483 GLboolean DepthClamp; /**< GL_ARB_depth_clamp */ 1484 1485 GLfloat CullEyePos[4]; 1486 GLfloat CullObjPos[4]; 1487}; 1488 1489 1490/** 1491 * Viewport attribute group (GL_VIEWPORT_BIT). 1492 */ 1493struct gl_viewport_attrib 1494{ 1495 GLint X, Y; /**< position */ 1496 GLsizei Width, Height; /**< size */ 1497 GLfloat Near, Far; /**< Depth buffer range */ 1498 GLmatrix _WindowMap; /**< Mapping transformation as a matrix. */ 1499}; 1500 1501 1502/** 1503 * GL_ARB_vertex/pixel_buffer_object buffer object 1504 */ 1505struct gl_buffer_object 1506{ 1507 _glthread_Mutex Mutex; 1508 GLint RefCount; 1509 GLuint Name; 1510 GLenum Usage; /**< GL_STREAM_DRAW_ARB, GL_STREAM_READ_ARB, etc. */ 1511 GLsizeiptrARB Size; /**< Size of buffer storage in bytes */ 1512 GLubyte *Data; /**< Location of storage either in RAM or VRAM. */ 1513 /** Fields describing a mapped buffer */ 1514 /*@{*/ 1515 GLbitfield AccessFlags; /**< Mask of GL_MAP_x_BIT flags */ 1516 GLvoid *Pointer; /**< User-space address of mapping */ 1517 GLintptr Offset; /**< Mapped offset */ 1518 GLsizeiptr Length; /**< Mapped length */ 1519 /*@}*/ 1520 GLboolean DeletePending; /**< true if buffer object is removed from the hash */ 1521 GLboolean Written; /**< Ever written to? (for debugging) */ 1522 GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */ 1523}; 1524 1525 1526/** 1527 * Client pixel packing/unpacking attributes 1528 */ 1529struct gl_pixelstore_attrib 1530{ 1531 GLint Alignment; 1532 GLint RowLength; 1533 GLint SkipPixels; 1534 GLint SkipRows; 1535 GLint ImageHeight; 1536 GLint SkipImages; 1537 GLboolean SwapBytes; 1538 GLboolean LsbFirst; 1539 GLboolean Invert; /**< GL_MESA_pack_invert */ 1540 struct gl_buffer_object *BufferObj; /**< GL_ARB_pixel_buffer_object */ 1541}; 1542 1543 1544/** 1545 * Client vertex array attributes 1546 */ 1547struct gl_client_array 1548{ 1549 GLint Size; /**< components per element (1,2,3,4) */ 1550 GLenum Type; /**< datatype: GL_FLOAT, GL_INT, etc */ 1551 GLenum Format; /**< default: GL_RGBA, but may be GL_BGRA */ 1552 GLsizei Stride; /**< user-specified stride */ 1553 GLsizei StrideB; /**< actual stride in bytes */ 1554 const GLubyte *Ptr; /**< Points to array data */ 1555 GLboolean Enabled; /**< Enabled flag is a boolean */ 1556 GLboolean Normalized; /**< GL_ARB_vertex_program */ 1557 GLboolean Integer; /**< Integer-valued? */ 1558 GLuint InstanceDivisor; /**< GL_ARB_instanced_arrays */ 1559 GLuint _ElementSize; /**< size of each element in bytes */ 1560 1561 struct gl_buffer_object *BufferObj;/**< GL_ARB_vertex_buffer_object */ 1562 GLuint _MaxElement; /**< max element index into array buffer + 1 */ 1563}; 1564 1565 1566/** 1567 * Collection of vertex arrays. Defined by the GL_APPLE_vertex_array_object 1568 * extension, but a nice encapsulation in any case. 1569 */ 1570struct gl_array_object 1571{ 1572 /** Name of the array object as received from glGenVertexArrayAPPLE. */ 1573 GLuint Name; 1574 1575 GLint RefCount; 1576 _glthread_Mutex Mutex; 1577 1578 /** 1579 * Does the VAO use ARB semantics or Apple semantics? 1580 * 1581 * There are several ways in which ARB_vertex_array_object and 1582 * APPLE_vertex_array_object VAOs have differing semantics. At the very 1583 * least, 1584 * 1585 * - ARB VAOs require that all array data be sourced from vertex buffer 1586 * objects, but Apple VAOs do not. 1587 * 1588 * - ARB VAOs require that names come from GenVertexArrays. 1589 * 1590 * This flag notes which behavior governs this VAO. 1591 */ 1592 GLboolean ARBsemantics; 1593 1594 /** 1595 * Has this array object been bound? 1596 */ 1597 GLboolean _Used; 1598 1599 /** Vertex attribute arrays */ 1600 struct gl_client_array VertexAttrib[VERT_ATTRIB_MAX]; 1601 1602 /** Mask of VERT_BIT_* values indicating which arrays are enabled */ 1603 GLbitfield64 _Enabled; 1604 1605 /** Mask of VERT_BIT_* values indicating changed/dirty arrays */ 1606 GLbitfield64 NewArrays; 1607 1608 /** 1609 * Min of all enabled arrays' _MaxElement. When arrays reside inside VBOs 1610 * we can determine the max legal (in bounds) glDrawElements array index. 1611 */ 1612 GLuint _MaxElement; 1613 1614 struct gl_buffer_object *ElementArrayBufferObj; 1615}; 1616 1617 1618/** 1619 * Vertex array state 1620 */ 1621struct gl_array_attrib 1622{ 1623 /** Currently bound array object. See _mesa_BindVertexArrayAPPLE() */ 1624 struct gl_array_object *ArrayObj; 1625 1626 /** The default vertex array object */ 1627 struct gl_array_object *DefaultArrayObj; 1628 1629 /** Array objects (GL_ARB/APPLE_vertex_array_object) */ 1630 struct _mesa_HashTable *Objects; 1631 1632 GLint ActiveTexture; /**< Client Active Texture */ 1633 GLuint LockFirst; /**< GL_EXT_compiled_vertex_array */ 1634 GLuint LockCount; /**< GL_EXT_compiled_vertex_array */ 1635 1636 /** GL 3.1 (slightly different from GL_NV_primitive_restart) */ 1637 GLboolean PrimitiveRestart; 1638 GLuint RestartIndex; 1639 1640 /* GL_ARB_vertex_buffer_object */ 1641 struct gl_buffer_object *ArrayBufferObj; 1642 1643 /** 1644 * Vertex arrays as consumed by a driver. 1645 * The array pointer is set up only by the VBO module. */ 1646 const struct gl_client_array **_DrawArrays; /**< 0..VERT_ATTRIB_MAX-1 */ 1647}; 1648 1649 1650/** 1651 * Feedback buffer state 1652 */ 1653struct gl_feedback 1654{ 1655 GLenum Type; 1656 GLbitfield _Mask; /**< FB_* bits */ 1657 GLfloat *Buffer; 1658 GLuint BufferSize; 1659 GLuint Count; 1660}; 1661 1662 1663/** 1664 * Selection buffer state 1665 */ 1666struct gl_selection 1667{ 1668 GLuint *Buffer; /**< selection buffer */ 1669 GLuint BufferSize; /**< size of the selection buffer */ 1670 GLuint BufferCount; /**< number of values in the selection buffer */ 1671 GLuint Hits; /**< number of records in the selection buffer */ 1672 GLuint NameStackDepth; /**< name stack depth */ 1673 GLuint NameStack[MAX_NAME_STACK_DEPTH]; /**< name stack */ 1674 GLboolean HitFlag; /**< hit flag */ 1675 GLfloat HitMinZ; /**< minimum hit depth */ 1676 GLfloat HitMaxZ; /**< maximum hit depth */ 1677}; 1678 1679 1680/** 1681 * 1-D Evaluator control points 1682 */ 1683struct gl_1d_map 1684{ 1685 GLuint Order; /**< Number of control points */ 1686 GLfloat u1, u2, du; /**< u1, u2, 1.0/(u2-u1) */ 1687 GLfloat *Points; /**< Points to contiguous control points */ 1688}; 1689 1690 1691/** 1692 * 2-D Evaluator control points 1693 */ 1694struct gl_2d_map 1695{ 1696 GLuint Uorder; /**< Number of control points in U dimension */ 1697 GLuint Vorder; /**< Number of control points in V dimension */ 1698 GLfloat u1, u2, du; 1699 GLfloat v1, v2, dv; 1700 GLfloat *Points; /**< Points to contiguous control points */ 1701}; 1702 1703 1704/** 1705 * All evaluator control point state 1706 */ 1707struct gl_evaluators 1708{ 1709 /** 1710 * \name 1-D maps 1711 */ 1712 /*@{*/ 1713 struct gl_1d_map Map1Vertex3; 1714 struct gl_1d_map Map1Vertex4; 1715 struct gl_1d_map Map1Index; 1716 struct gl_1d_map Map1Color4; 1717 struct gl_1d_map Map1Normal; 1718 struct gl_1d_map Map1Texture1; 1719 struct gl_1d_map Map1Texture2; 1720 struct gl_1d_map Map1Texture3; 1721 struct gl_1d_map Map1Texture4; 1722 struct gl_1d_map Map1Attrib[16]; /**< GL_NV_vertex_program */ 1723 /*@}*/ 1724 1725 /** 1726 * \name 2-D maps 1727 */ 1728 /*@{*/ 1729 struct gl_2d_map Map2Vertex3; 1730 struct gl_2d_map Map2Vertex4; 1731 struct gl_2d_map Map2Index; 1732 struct gl_2d_map Map2Color4; 1733 struct gl_2d_map Map2Normal; 1734 struct gl_2d_map Map2Texture1; 1735 struct gl_2d_map Map2Texture2; 1736 struct gl_2d_map Map2Texture3; 1737 struct gl_2d_map Map2Texture4; 1738 struct gl_2d_map Map2Attrib[16]; /**< GL_NV_vertex_program */ 1739 /*@}*/ 1740}; 1741 1742 1743struct gl_transform_feedback_varying_info 1744{ 1745 char *Name; 1746 GLenum Type; 1747 GLint Size; 1748}; 1749 1750 1751/** 1752 * Per-output info vertex shaders for transform feedback. 1753 */ 1754struct gl_transform_feedback_output 1755{ 1756 unsigned OutputRegister; 1757 unsigned OutputBuffer; 1758 unsigned NumComponents; 1759 1760 /** offset (in DWORDs) of this output within the interleaved structure */ 1761 unsigned DstOffset; 1762 1763 /** 1764 * Offset into the output register of the data to output. For example, 1765 * if NumComponents is 2 and ComponentOffset is 1, then the data to 1766 * offset is in the y and z components of the output register. 1767 */ 1768 unsigned ComponentOffset; 1769}; 1770 1771 1772/** Post-link transform feedback info. */ 1773struct gl_transform_feedback_info 1774{ 1775 unsigned NumOutputs; 1776 1777 /** 1778 * Number of transform feedback buffers in use by this program. 1779 */ 1780 unsigned NumBuffers; 1781 1782 struct gl_transform_feedback_output *Outputs; 1783 1784 /** Transform feedback varyings used for the linking of this shader program. 1785 * 1786 * Use for glGetTransformFeedbackVarying(). 1787 */ 1788 struct gl_transform_feedback_varying_info *Varyings; 1789 GLint NumVarying; 1790 1791 /** 1792 * Total number of components stored in each buffer. This may be used by 1793 * hardware back-ends to determine the correct stride when interleaving 1794 * multiple transform feedback outputs in the same buffer. 1795 */ 1796 unsigned BufferStride[MAX_FEEDBACK_BUFFERS]; 1797}; 1798 1799 1800/** 1801 * Transform feedback object state 1802 */ 1803struct gl_transform_feedback_object 1804{ 1805 GLuint Name; /**< AKA the object ID */ 1806 GLint RefCount; 1807 GLboolean Active; /**< Is transform feedback enabled? */ 1808 GLboolean Paused; /**< Is transform feedback paused? */ 1809 GLboolean EndedAnytime; /**< Has EndTransformFeedback been called 1810 at least once? */ 1811 1812 /** The feedback buffers */ 1813 GLuint BufferNames[MAX_FEEDBACK_BUFFERS]; 1814 struct gl_buffer_object *Buffers[MAX_FEEDBACK_BUFFERS]; 1815 1816 /** Start of feedback data in dest buffer */ 1817 GLintptr Offset[MAX_FEEDBACK_BUFFERS]; 1818 /** Max data to put into dest buffer (in bytes) */ 1819 GLsizeiptr Size[MAX_FEEDBACK_BUFFERS]; 1820}; 1821 1822 1823/** 1824 * Context state for transform feedback. 1825 */ 1826struct gl_transform_feedback_state 1827{ 1828 GLenum Mode; /**< GL_POINTS, GL_LINES or GL_TRIANGLES */ 1829 1830 /** The general binding point (GL_TRANSFORM_FEEDBACK_BUFFER) */ 1831 struct gl_buffer_object *CurrentBuffer; 1832 1833 /** The table of all transform feedback objects */ 1834 struct _mesa_HashTable *Objects; 1835 1836 /** The current xform-fb object (GL_TRANSFORM_FEEDBACK_BINDING) */ 1837 struct gl_transform_feedback_object *CurrentObject; 1838 1839 /** The default xform-fb object (Name==0) */ 1840 struct gl_transform_feedback_object *DefaultObject; 1841}; 1842 1843 1844/** 1845 * Names of the various vertex/fragment program register files, etc. 1846 * 1847 * NOTE: first four tokens must fit into 2 bits (see t_vb_arbprogram.c) 1848 * All values should fit in a 4-bit field. 1849 * 1850 * NOTE: PROGRAM_ENV_PARAM, PROGRAM_STATE_VAR, PROGRAM_NAMED_PARAM, 1851 * PROGRAM_CONSTANT, and PROGRAM_UNIFORM can all be considered to 1852 * be "uniform" variables since they can only be set outside glBegin/End. 1853 * They're also all stored in the same Parameters array. 1854 */ 1855typedef enum 1856{ 1857 PROGRAM_TEMPORARY, /**< machine->Temporary[] */ 1858 PROGRAM_INPUT, /**< machine->Inputs[] */ 1859 PROGRAM_OUTPUT, /**< machine->Outputs[] */ 1860 PROGRAM_VARYING, /**< machine->Inputs[]/Outputs[] */ 1861 PROGRAM_LOCAL_PARAM, /**< gl_program->LocalParams[] */ 1862 PROGRAM_ENV_PARAM, /**< gl_program->Parameters[] */ 1863 PROGRAM_STATE_VAR, /**< gl_program->Parameters[] */ 1864 PROGRAM_NAMED_PARAM, /**< gl_program->Parameters[] */ 1865 PROGRAM_CONSTANT, /**< gl_program->Parameters[] */ 1866 PROGRAM_UNIFORM, /**< gl_program->Parameters[] */ 1867 PROGRAM_WRITE_ONLY, /**< A dummy, write-only register */ 1868 PROGRAM_ADDRESS, /**< machine->AddressReg */ 1869 PROGRAM_SAMPLER, /**< for shader samplers, compile-time only */ 1870 PROGRAM_SYSTEM_VALUE,/**< InstanceId, PrimitiveID, etc. */ 1871 PROGRAM_UNDEFINED, /**< Invalid/TBD value */ 1872 PROGRAM_FILE_MAX 1873} gl_register_file; 1874 1875 1876/** 1877 * If the register file is PROGRAM_SYSTEM_VALUE, the register index will be 1878 * one of these values. 1879 */ 1880typedef enum 1881{ 1882 SYSTEM_VALUE_FRONT_FACE, /**< Fragment shader only (not done yet) */ 1883 SYSTEM_VALUE_VERTEX_ID, /**< Vertex shader only */ 1884 SYSTEM_VALUE_INSTANCE_ID, /**< Vertex shader only */ 1885 SYSTEM_VALUE_MAX /**< Number of values */ 1886} gl_system_value; 1887 1888 1889/** 1890 * The possible interpolation qualifiers that can be applied to a fragment 1891 * shader input in GLSL. 1892 * 1893 * Note: INTERP_QUALIFIER_NONE must be 0 so that memsetting the 1894 * gl_fragment_program data structure to 0 causes the default behavior. 1895 */ 1896enum glsl_interp_qualifier 1897{ 1898 INTERP_QUALIFIER_NONE = 0, 1899 INTERP_QUALIFIER_SMOOTH, 1900 INTERP_QUALIFIER_FLAT, 1901 INTERP_QUALIFIER_NOPERSPECTIVE 1902}; 1903 1904 1905/** 1906 * \brief Layout qualifiers for gl_FragDepth. 1907 * 1908 * Extension AMD_conservative_depth allows gl_FragDepth to be redeclared with 1909 * a layout qualifier. 1910 * 1911 * \see enum ir_depth_layout 1912 */ 1913enum gl_frag_depth_layout 1914{ 1915 FRAG_DEPTH_LAYOUT_NONE, /**< No layout is specified. */ 1916 FRAG_DEPTH_LAYOUT_ANY, 1917 FRAG_DEPTH_LAYOUT_GREATER, 1918 FRAG_DEPTH_LAYOUT_LESS, 1919 FRAG_DEPTH_LAYOUT_UNCHANGED 1920}; 1921 1922 1923/** 1924 * Base class for any kind of program object 1925 */ 1926struct gl_program 1927{ 1928 GLuint Id; 1929 GLubyte *String; /**< Null-terminated program text */ 1930 GLint RefCount; 1931 GLenum Target; /**< GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_FRAGMENT_PROGRAM_NV */ 1932 GLenum Format; /**< String encoding format */ 1933 GLboolean Resident; 1934 1935 struct prog_instruction *Instructions; 1936 1937 GLbitfield64 InputsRead; /**< Bitmask of which input regs are read */ 1938 GLbitfield64 OutputsWritten; /**< Bitmask of which output regs are written */ 1939 GLbitfield SystemValuesRead; /**< Bitmask of SYSTEM_VALUE_x inputs used */ 1940 GLbitfield InputFlags[MAX_PROGRAM_INPUTS]; /**< PROG_PARAM_BIT_x flags */ 1941 GLbitfield OutputFlags[MAX_PROGRAM_OUTPUTS]; /**< PROG_PARAM_BIT_x flags */ 1942 GLbitfield TexturesUsed[MAX_COMBINED_TEXTURE_IMAGE_UNITS]; /**< TEXTURE_x_BIT bitmask */ 1943 GLbitfield SamplersUsed; /**< Bitfield of which samplers are used */ 1944 GLbitfield ShadowSamplers; /**< Texture units used for shadow sampling. */ 1945 1946 1947 /** Named parameters, constants, etc. from program text */ 1948 struct gl_program_parameter_list *Parameters; 1949 /** Numbered local parameters */ 1950 GLfloat LocalParams[MAX_PROGRAM_LOCAL_PARAMS][4]; 1951 1952 /** Map from sampler unit to texture unit (set by glUniform1i()) */ 1953 GLubyte SamplerUnits[MAX_SAMPLERS]; 1954 1955 /** Bitmask of which register files are read/written with indirect 1956 * addressing. Mask of (1 << PROGRAM_x) bits. 1957 */ 1958 GLbitfield IndirectRegisterFiles; 1959 1960 /** Logical counts */ 1961 /*@{*/ 1962 GLuint NumInstructions; 1963 GLuint NumTemporaries; 1964 GLuint NumParameters; 1965 GLuint NumAttributes; 1966 GLuint NumAddressRegs; 1967 GLuint NumAluInstructions; 1968 GLuint NumTexInstructions; 1969 GLuint NumTexIndirections; 1970 /*@}*/ 1971 /** Native, actual h/w counts */ 1972 /*@{*/ 1973 GLuint NumNativeInstructions; 1974 GLuint NumNativeTemporaries; 1975 GLuint NumNativeParameters; 1976 GLuint NumNativeAttributes; 1977 GLuint NumNativeAddressRegs; 1978 GLuint NumNativeAluInstructions; 1979 GLuint NumNativeTexInstructions; 1980 GLuint NumNativeTexIndirections; 1981 /*@}*/ 1982}; 1983 1984 1985/** Vertex program object */ 1986struct gl_vertex_program 1987{ 1988 struct gl_program Base; /**< base class */ 1989 GLboolean IsNVProgram; /**< is this a GL_NV_vertex_program program? */ 1990 GLboolean IsPositionInvariant; 1991 GLboolean UsesClipDistance; 1992}; 1993 1994 1995/** Geometry program object */ 1996struct gl_geometry_program 1997{ 1998 struct gl_program Base; /**< base class */ 1999 2000 GLint VerticesOut; 2001 GLenum InputType; /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB, 2002 GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */ 2003 GLenum OutputType; /**< GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP */ 2004}; 2005 2006 2007/** Fragment program object */ 2008struct gl_fragment_program 2009{ 2010 struct gl_program Base; /**< base class */ 2011 GLboolean UsesKill; /**< shader uses KIL instruction */ 2012 GLboolean UsesDFdy; /**< shader uses DDY instruction */ 2013 GLboolean OriginUpperLeft; 2014 GLboolean PixelCenterInteger; 2015 enum gl_frag_depth_layout FragDepthLayout; 2016 2017 /** 2018 * GLSL interpolation qualifier associated with each fragment shader input. 2019 * For inputs that do not have an interpolation qualifier specified in 2020 * GLSL, the value is INTERP_QUALIFIER_NONE. 2021 */ 2022 enum glsl_interp_qualifier InterpQualifier[FRAG_ATTRIB_MAX]; 2023 2024 /** 2025 * Bitfield indicating, for each fragment shader input, 1 if that input 2026 * uses centroid interpolation, 0 otherwise. Unused inputs are 0. 2027 */ 2028 GLbitfield64 IsCentroid; 2029}; 2030 2031 2032/** 2033 * State common to vertex and fragment programs. 2034 */ 2035struct gl_program_state 2036{ 2037 GLint ErrorPos; /* GL_PROGRAM_ERROR_POSITION_ARB/NV */ 2038 const char *ErrorString; /* GL_PROGRAM_ERROR_STRING_ARB/NV */ 2039}; 2040 2041 2042/** 2043 * Context state for vertex programs. 2044 */ 2045struct gl_vertex_program_state 2046{ 2047 GLboolean Enabled; /**< User-set GL_VERTEX_PROGRAM_ARB/NV flag */ 2048 GLboolean _Enabled; /**< Enabled and _valid_ user program? */ 2049 GLboolean PointSizeEnabled; /**< GL_VERTEX_PROGRAM_POINT_SIZE_ARB/NV */ 2050 GLboolean TwoSideEnabled; /**< GL_VERTEX_PROGRAM_TWO_SIDE_ARB/NV */ 2051 /** Computed two sided lighting for fixed function/programs. */ 2052 GLboolean _TwoSideEnabled; 2053 struct gl_vertex_program *Current; /**< User-bound vertex program */ 2054 2055 /** Currently enabled and valid vertex program (including internal 2056 * programs, user-defined vertex programs and GLSL vertex shaders). 2057 * This is the program we must use when rendering. 2058 */ 2059 struct gl_vertex_program *_Current; 2060 2061 GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */ 2062 2063 /* For GL_NV_vertex_program only: */ 2064 GLenum TrackMatrix[MAX_PROGRAM_ENV_PARAMS / 4]; 2065 GLenum TrackMatrixTransform[MAX_PROGRAM_ENV_PARAMS / 4]; 2066 2067 /** Should fixed-function T&L be implemented with a vertex prog? */ 2068 GLboolean _MaintainTnlProgram; 2069 2070 /** Program to emulate fixed-function T&L (see above) */ 2071 struct gl_vertex_program *_TnlProgram; 2072 2073 /** Cache of fixed-function programs */ 2074 struct gl_program_cache *Cache; 2075 2076 GLboolean _Overriden; 2077}; 2078 2079 2080/** 2081 * Context state for geometry programs. 2082 */ 2083struct gl_geometry_program_state 2084{ 2085 GLboolean Enabled; /**< GL_ARB_GEOMETRY_SHADER4 */ 2086 GLboolean _Enabled; /**< Enabled and valid program? */ 2087 struct gl_geometry_program *Current; /**< user-bound geometry program */ 2088 2089 /** Currently enabled and valid program (including internal programs 2090 * and compiled shader programs). 2091 */ 2092 struct gl_geometry_program *_Current; 2093 2094 GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */ 2095 2096 /** Cache of fixed-function programs */ 2097 struct gl_program_cache *Cache; 2098}; 2099 2100/** 2101 * Context state for fragment programs. 2102 */ 2103struct gl_fragment_program_state 2104{ 2105 GLboolean Enabled; /**< User-set fragment program enable flag */ 2106 GLboolean _Enabled; /**< Enabled and _valid_ user program? */ 2107 struct gl_fragment_program *Current; /**< User-bound fragment program */ 2108 2109 /** Currently enabled and valid fragment program (including internal 2110 * programs, user-defined fragment programs and GLSL fragment shaders). 2111 * This is the program we must use when rendering. 2112 */ 2113 struct gl_fragment_program *_Current; 2114 2115 GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */ 2116 2117 /** Should fixed-function texturing be implemented with a fragment prog? */ 2118 GLboolean _MaintainTexEnvProgram; 2119 2120 /** Program to emulate fixed-function texture env/combine (see above) */ 2121 struct gl_fragment_program *_TexEnvProgram; 2122 2123 /** Cache of fixed-function programs */ 2124 struct gl_program_cache *Cache; 2125}; 2126 2127 2128/** 2129 * ATI_fragment_shader runtime state 2130 */ 2131#define ATI_FS_INPUT_PRIMARY 0 2132#define ATI_FS_INPUT_SECONDARY 1 2133 2134struct atifs_instruction; 2135struct atifs_setupinst; 2136 2137/** 2138 * ATI fragment shader 2139 */ 2140struct ati_fragment_shader 2141{ 2142 GLuint Id; 2143 GLint RefCount; 2144 struct atifs_instruction *Instructions[2]; 2145 struct atifs_setupinst *SetupInst[2]; 2146 GLfloat Constants[8][4]; 2147 GLbitfield LocalConstDef; /**< Indicates which constants have been set */ 2148 GLubyte numArithInstr[2]; 2149 GLubyte regsAssigned[2]; 2150 GLubyte NumPasses; /**< 1 or 2 */ 2151 GLubyte cur_pass; 2152 GLubyte last_optype; 2153 GLboolean interpinp1; 2154 GLboolean isValid; 2155 GLuint swizzlerq; 2156}; 2157 2158/** 2159 * Context state for GL_ATI_fragment_shader 2160 */ 2161struct gl_ati_fragment_shader_state 2162{ 2163 GLboolean Enabled; 2164 GLboolean _Enabled; /**< enabled and valid shader? */ 2165 GLboolean Compiling; 2166 GLfloat GlobalConstants[8][4]; 2167 struct ati_fragment_shader *Current; 2168}; 2169 2170 2171/** Set by #pragma directives */ 2172struct gl_sl_pragmas 2173{ 2174 GLboolean IgnoreOptimize; /**< ignore #pragma optimize(on/off) ? */ 2175 GLboolean IgnoreDebug; /**< ignore #pragma debug(on/off) ? */ 2176 GLboolean Optimize; /**< defaults on */ 2177 GLboolean Debug; /**< defaults off */ 2178}; 2179 2180 2181/** 2182 * A GLSL vertex or fragment shader object. 2183 */ 2184struct gl_shader 2185{ 2186 GLenum Type; /**< GL_FRAGMENT_SHADER || GL_VERTEX_SHADER || GL_GEOMETRY_SHADER_ARB (first field!) */ 2187 GLuint Name; /**< AKA the handle */ 2188 GLint RefCount; /**< Reference count */ 2189 GLboolean DeletePending; 2190 GLboolean CompileStatus; 2191 const GLchar *Source; /**< Source code string */ 2192 GLuint SourceChecksum; /**< for debug/logging purposes */ 2193 struct gl_program *Program; /**< Post-compile assembly code */ 2194 GLchar *InfoLog; 2195 struct gl_sl_pragmas Pragmas; 2196 2197 unsigned Version; /**< GLSL version used for linking */ 2198 2199 /** 2200 * \name Sampler tracking 2201 * 2202 * \note Each of these fields is only set post-linking. 2203 */ 2204 /*@{*/ 2205 unsigned num_samplers; /**< Number of samplers used by this shader. */ 2206 GLbitfield active_samplers; /**< Bitfield of which samplers are used */ 2207 GLbitfield shadow_samplers; /**< Samplers used for shadow sampling. */ 2208 /*@}*/ 2209 2210 /** 2211 * Number of uniform components used by this shader. 2212 * 2213 * This field is only set post-linking. 2214 */ 2215 unsigned num_uniform_components; 2216 2217 /** 2218 * This shader's uniform block information. 2219 * 2220 * The offsets of the variables are assigned only for shaders in a program's 2221 * _LinkedShaders[]. 2222 */ 2223 struct gl_uniform_block *UniformBlocks; 2224 unsigned NumUniformBlocks; 2225 2226 struct exec_list *ir; 2227 struct glsl_symbol_table *symbols; 2228 2229 /** Shaders containing built-in functions that are used for linking. */ 2230 struct gl_shader *builtins_to_link[16]; 2231 unsigned num_builtins_to_link; 2232}; 2233 2234 2235/** 2236 * Shader stages. Note that these will become 5 with tessellation. 2237 * These MUST have the same values as gallium's PIPE_SHADER_* 2238 */ 2239typedef enum 2240{ 2241 MESA_SHADER_VERTEX = 0, 2242 MESA_SHADER_FRAGMENT = 1, 2243 MESA_SHADER_GEOMETRY = 2, 2244 MESA_SHADER_TYPES = 3 2245} gl_shader_type; 2246 2247struct gl_uniform_buffer_variable 2248{ 2249 char *Name; 2250 const struct glsl_type *Type; 2251 unsigned int Buffer; 2252 unsigned int Offset; 2253 GLboolean RowMajor; 2254}; 2255 2256struct gl_uniform_block 2257{ 2258 /** Declared name of the uniform block */ 2259 char *Name; 2260 2261 /** Array of supplemental information about UBO ir_variables. */ 2262 struct gl_uniform_buffer_variable *Uniforms; 2263 GLuint NumUniforms; 2264 2265 /** 2266 * Index (GL_UNIFORM_BLOCK_BINDING) into ctx->UniformBufferBindings[] to use 2267 * with glBindBufferBase to bind a buffer object to this uniform block. When 2268 * updated in the program, _NEW_BUFFER_OBJECT will be set. 2269 */ 2270 GLuint Binding; 2271 2272 /** 2273 * Minimum size of a buffer object to back this uniform buffer 2274 * (GL_UNIFORM_BLOCK_DATA_SIZE). 2275 */ 2276 GLuint UniformBufferSize; 2277}; 2278 2279/** 2280 * A GLSL program object. 2281 * Basically a linked collection of vertex and fragment shaders. 2282 */ 2283struct gl_shader_program 2284{ 2285 GLenum Type; /**< Always GL_SHADER_PROGRAM (internal token) */ 2286 GLuint Name; /**< aka handle or ID */ 2287 GLint RefCount; /**< Reference count */ 2288 GLboolean DeletePending; 2289 2290 /** 2291 * Flags that the linker should not reject the program if it lacks 2292 * a vertex or fragment shader. GLES2 doesn't allow separate 2293 * shader objects, and would reject them. However, we internally 2294 * build separate shader objects for fixed function programs, which 2295 * we use for drivers/common/meta.c and for handling 2296 * _mesa_update_state with no program bound (for example in 2297 * glClear()). 2298 */ 2299 GLboolean InternalSeparateShader; 2300 2301 GLuint NumShaders; /**< number of attached shaders */ 2302 struct gl_shader **Shaders; /**< List of attached the shaders */ 2303 2304 /** 2305 * User-defined attribute bindings 2306 * 2307 * These are set via \c glBindAttribLocation and are used to direct the 2308 * GLSL linker. These are \b not the values used in the compiled shader, 2309 * and they are \b not the values returned by \c glGetAttribLocation. 2310 */ 2311 struct string_to_uint_map *AttributeBindings; 2312 2313 /** 2314 * User-defined fragment data bindings 2315 * 2316 * These are set via \c glBindFragDataLocation and are used to direct the 2317 * GLSL linker. These are \b not the values used in the compiled shader, 2318 * and they are \b not the values returned by \c glGetFragDataLocation. 2319 */ 2320 struct string_to_uint_map *FragDataBindings; 2321 struct string_to_uint_map *FragDataIndexBindings; 2322 2323 /** 2324 * Transform feedback varyings last specified by 2325 * glTransformFeedbackVaryings(). 2326 * 2327 * For the current set of transform feeedback varyings used for transform 2328 * feedback output, see LinkedTransformFeedback. 2329 */ 2330 struct { 2331 GLenum BufferMode; 2332 GLuint NumVarying; 2333 GLchar **VaryingNames; /**< Array [NumVarying] of char * */ 2334 } TransformFeedback; 2335 2336 /** Post-link transform feedback info. */ 2337 struct gl_transform_feedback_info LinkedTransformFeedback; 2338 2339 /** Post-link gl_FragDepth layout for ARB_conservative_depth. */ 2340 enum gl_frag_depth_layout FragDepthLayout; 2341 2342 /** Geometry shader state - copied into gl_geometry_program at link time */ 2343 struct { 2344 GLint VerticesOut; 2345 GLenum InputType; /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB, 2346 GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */ 2347 GLenum OutputType; /**< GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP */ 2348 } Geom; 2349 2350 /** Vertex shader state - copied into gl_vertex_program at link time */ 2351 struct { 2352 GLboolean UsesClipDistance; /**< True if gl_ClipDistance is written to. */ 2353 GLuint ClipDistanceArraySize; /**< Size of the gl_ClipDistance array, or 2354 0 if not present. */ 2355 } Vert; 2356 2357 /* post-link info: */ 2358 unsigned NumUserUniformStorage; 2359 struct gl_uniform_storage *UniformStorage; 2360 2361 struct gl_uniform_block *UniformBlocks; 2362 unsigned NumUniformBlocks; 2363 2364 /** 2365 * Indices into the _LinkedShaders's UniformBlocks[] array for each stage 2366 * they're used in, or -1. 2367 * 2368 * This is used to maintain the Binding values of the stage's UniformBlocks[] 2369 * and to answer the GL_UNIFORM_BLOCK_REFERENCED_BY_*_SHADER queries. 2370 */ 2371 int *UniformBlockStageIndex[MESA_SHADER_TYPES]; 2372 2373 /** 2374 * Map of active uniform names to locations 2375 * 2376 * Maps any active uniform that is not an array element to a location. 2377 * Each active uniform, including individual structure members will appear 2378 * in this map. This roughly corresponds to the set of names that would be 2379 * enumerated by \c glGetActiveUniform. 2380 */ 2381 struct string_to_uint_map *UniformHash; 2382 2383 /** 2384 * Map from sampler unit to texture unit (set by glUniform1i()) 2385 * 2386 * A sampler unit is associated with each sampler uniform by the linker. 2387 * The sampler unit associated with each uniform is stored in the 2388 * \c gl_uniform_storage::sampler field. 2389 */ 2390 GLubyte SamplerUnits[MAX_SAMPLERS]; 2391 /** Which texture target is being sampled (TEXTURE_1D/2D/3D/etc_INDEX) */ 2392 gl_texture_index SamplerTargets[MAX_SAMPLERS]; 2393 2394 GLboolean LinkStatus; /**< GL_LINK_STATUS */ 2395 GLboolean Validated; 2396 GLboolean _Used; /**< Ever used for drawing? */ 2397 GLchar *InfoLog; 2398 2399 unsigned Version; /**< GLSL version used for linking */ 2400 2401 /** 2402 * Per-stage shaders resulting from the first stage of linking. 2403 * 2404 * Set of linked shaders for this program. The array is accessed using the 2405 * \c MESA_SHADER_* defines. Entries for non-existent stages will be 2406 * \c NULL. 2407 */ 2408 struct gl_shader *_LinkedShaders[MESA_SHADER_TYPES]; 2409}; 2410 2411 2412#define GLSL_DUMP 0x1 /**< Dump shaders to stdout */ 2413#define GLSL_LOG 0x2 /**< Write shaders to files */ 2414#define GLSL_OPT 0x4 /**< Force optimizations (override pragmas) */ 2415#define GLSL_NO_OPT 0x8 /**< Force no optimizations (override pragmas) */ 2416#define GLSL_UNIFORMS 0x10 /**< Print glUniform calls */ 2417#define GLSL_NOP_VERT 0x20 /**< Force no-op vertex shaders */ 2418#define GLSL_NOP_FRAG 0x40 /**< Force no-op fragment shaders */ 2419#define GLSL_USE_PROG 0x80 /**< Log glUseProgram calls */ 2420#define GLSL_REPORT_ERRORS 0x100 /**< Print compilation errors */ 2421 2422 2423/** 2424 * Context state for GLSL vertex/fragment shaders. 2425 */ 2426struct gl_shader_state 2427{ 2428 /** 2429 * Programs used for rendering 2430 * 2431 * There is a separate program set for each shader stage. If 2432 * GL_EXT_separate_shader_objects is not supported, each of these must point 2433 * to \c NULL or to the same program. 2434 */ 2435 struct gl_shader_program *CurrentVertexProgram; 2436 struct gl_shader_program *CurrentGeometryProgram; 2437 struct gl_shader_program *CurrentFragmentProgram; 2438 2439 struct gl_shader_program *_CurrentFragmentProgram; 2440 2441 /** 2442 * Program used by glUniform calls. 2443 * 2444 * Explicitly set by \c glUseProgram and \c glActiveProgramEXT. 2445 */ 2446 struct gl_shader_program *ActiveProgram; 2447 2448 GLbitfield Flags; /**< Mask of GLSL_x flags */ 2449}; 2450 2451 2452/** 2453 * Compiler options for a single GLSL shaders type 2454 */ 2455struct gl_shader_compiler_options 2456{ 2457 /** Driver-selectable options: */ 2458 GLboolean EmitCondCodes; /**< Use condition codes? */ 2459 GLboolean EmitNVTempInitialization; /**< 0-fill NV temp registers */ 2460 GLboolean EmitNoLoops; 2461 GLboolean EmitNoFunctions; 2462 GLboolean EmitNoCont; /**< Emit CONT opcode? */ 2463 GLboolean EmitNoMainReturn; /**< Emit CONT/RET opcodes? */ 2464 GLboolean EmitNoNoise; /**< Emit NOISE opcodes? */ 2465 GLboolean EmitNoPow; /**< Emit POW opcodes? */ 2466 GLboolean LowerClipDistance; /**< Lower gl_ClipDistance from float[8] to vec4[2]? */ 2467 2468 /** 2469 * \name Forms of indirect addressing the driver cannot do. 2470 */ 2471 /*@{*/ 2472 GLboolean EmitNoIndirectInput; /**< No indirect addressing of inputs */ 2473 GLboolean EmitNoIndirectOutput; /**< No indirect addressing of outputs */ 2474 GLboolean EmitNoIndirectTemp; /**< No indirect addressing of temps */ 2475 GLboolean EmitNoIndirectUniform; /**< No indirect addressing of constants */ 2476 /*@}*/ 2477 2478 GLuint MaxIfDepth; /**< Maximum nested IF blocks */ 2479 GLuint MaxUnrollIterations; 2480 2481 struct gl_sl_pragmas DefaultPragmas; /**< Default #pragma settings */ 2482}; 2483 2484 2485/** 2486 * Occlusion/timer query object. 2487 */ 2488struct gl_query_object 2489{ 2490 GLenum Target; /**< The query target, when active */ 2491 GLuint Id; /**< hash table ID/name */ 2492 GLuint64EXT Result; /**< the counter */ 2493 GLboolean Active; /**< inside Begin/EndQuery */ 2494 GLboolean Ready; /**< result is ready? */ 2495}; 2496 2497 2498/** 2499 * Context state for query objects. 2500 */ 2501struct gl_query_state 2502{ 2503 struct _mesa_HashTable *QueryObjects; 2504 struct gl_query_object *CurrentOcclusionObject; /* GL_ARB_occlusion_query */ 2505 struct gl_query_object *CurrentTimerObject; /* GL_EXT_timer_query */ 2506 2507 /** GL_NV_conditional_render */ 2508 struct gl_query_object *CondRenderQuery; 2509 2510 /** GL_EXT_transform_feedback */ 2511 struct gl_query_object *PrimitivesGenerated; 2512 struct gl_query_object *PrimitivesWritten; 2513 2514 /** GL_ARB_timer_query */ 2515 struct gl_query_object *TimeElapsed; 2516 2517 GLenum CondRenderMode; 2518}; 2519 2520 2521/** Sync object state */ 2522struct gl_sync_object 2523{ 2524 struct simple_node link; 2525 GLenum Type; /**< GL_SYNC_FENCE */ 2526 GLuint Name; /**< Fence name */ 2527 GLint RefCount; /**< Reference count */ 2528 GLboolean DeletePending; /**< Object was deleted while there were still 2529 * live references (e.g., sync not yet finished) 2530 */ 2531 GLenum SyncCondition; 2532 GLbitfield Flags; /**< Flags passed to glFenceSync */ 2533 GLuint StatusFlag:1; /**< Has the sync object been signaled? */ 2534}; 2535 2536 2537/** 2538 * State which can be shared by multiple contexts: 2539 */ 2540struct gl_shared_state 2541{ 2542 _glthread_Mutex Mutex; /**< for thread safety */ 2543 GLint RefCount; /**< Reference count */ 2544 struct _mesa_HashTable *DisplayList; /**< Display lists hash table */ 2545 struct _mesa_HashTable *TexObjects; /**< Texture objects hash table */ 2546 2547 /** Default texture objects (shared by all texture units) */ 2548 struct gl_texture_object *DefaultTex[NUM_TEXTURE_TARGETS]; 2549 2550 /** Fallback texture used when a bound texture is incomplete */ 2551 struct gl_texture_object *FallbackTex[NUM_TEXTURE_TARGETS]; 2552 2553 /** 2554 * \name Thread safety and statechange notification for texture 2555 * objects. 2556 * 2557 * \todo Improve the granularity of locking. 2558 */ 2559 /*@{*/ 2560 _glthread_Mutex TexMutex; /**< texobj thread safety */ 2561 GLuint TextureStateStamp; /**< state notification for shared tex */ 2562 /*@}*/ 2563 2564 /** Default buffer object for vertex arrays that aren't in VBOs */ 2565 struct gl_buffer_object *NullBufferObj; 2566 2567 /** 2568 * \name Vertex/geometry/fragment programs 2569 */ 2570 /*@{*/ 2571 struct _mesa_HashTable *Programs; /**< All vertex/fragment programs */ 2572 struct gl_vertex_program *DefaultVertexProgram; 2573 struct gl_fragment_program *DefaultFragmentProgram; 2574 struct gl_geometry_program *DefaultGeometryProgram; 2575 /*@}*/ 2576 2577 /* GL_ATI_fragment_shader */ 2578 struct _mesa_HashTable *ATIShaders; 2579 struct ati_fragment_shader *DefaultFragmentShader; 2580 2581 struct _mesa_HashTable *BufferObjects; 2582 2583 /** Table of both gl_shader and gl_shader_program objects */ 2584 struct _mesa_HashTable *ShaderObjects; 2585 2586 /* GL_EXT_framebuffer_object */ 2587 struct _mesa_HashTable *RenderBuffers; 2588 struct _mesa_HashTable *FrameBuffers; 2589 2590 /* GL_ARB_sync */ 2591 struct simple_node SyncObjects; 2592 2593 /** GL_ARB_sampler_objects */ 2594 struct _mesa_HashTable *SamplerObjects; 2595}; 2596 2597 2598 2599/** 2600 * Renderbuffers represent drawing surfaces such as color, depth and/or 2601 * stencil. A framebuffer object has a set of renderbuffers. 2602 * Drivers will typically derive subclasses of this type. 2603 */ 2604struct gl_renderbuffer 2605{ 2606 _glthread_Mutex Mutex; /**< for thread safety */ 2607 GLuint ClassID; /**< Useful for drivers */ 2608 GLuint Name; 2609 GLint RefCount; 2610 GLuint Width, Height; 2611 GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */ 2612 GLboolean AttachedAnytime; /**< TRUE if it was attached to a framebuffer */ 2613 GLubyte NumSamples; 2614 GLenum InternalFormat; /**< The user-specified format */ 2615 GLenum _BaseFormat; /**< Either GL_RGB, GL_RGBA, GL_DEPTH_COMPONENT or 2616 GL_STENCIL_INDEX. */ 2617 gl_format Format; /**< The actual renderbuffer memory format */ 2618 2619 /** Delete this renderbuffer */ 2620 void (*Delete)(struct gl_renderbuffer *rb); 2621 2622 /** Allocate new storage for this renderbuffer */ 2623 GLboolean (*AllocStorage)(struct gl_context *ctx, 2624 struct gl_renderbuffer *rb, 2625 GLenum internalFormat, 2626 GLuint width, GLuint height); 2627}; 2628 2629 2630/** 2631 * A renderbuffer attachment points to either a texture object (and specifies 2632 * a mipmap level, cube face or 3D texture slice) or points to a renderbuffer. 2633 */ 2634struct gl_renderbuffer_attachment 2635{ 2636 GLenum Type; /**< \c GL_NONE or \c GL_TEXTURE or \c GL_RENDERBUFFER_EXT */ 2637 GLboolean Complete; 2638 2639 /** 2640 * If \c Type is \c GL_RENDERBUFFER_EXT, this stores a pointer to the 2641 * application supplied renderbuffer object. 2642 */ 2643 struct gl_renderbuffer *Renderbuffer; 2644 2645 /** 2646 * If \c Type is \c GL_TEXTURE, this stores a pointer to the application 2647 * supplied texture object. 2648 */ 2649 struct gl_texture_object *Texture; 2650 GLuint TextureLevel; /**< Attached mipmap level. */ 2651 GLuint CubeMapFace; /**< 0 .. 5, for cube map textures. */ 2652 GLuint Zoffset; /**< Slice for 3D textures, or layer for both 1D 2653 * and 2D array textures */ 2654}; 2655 2656 2657/** 2658 * A framebuffer is a collection of renderbuffers (color, depth, stencil, etc). 2659 * In C++ terms, think of this as a base class from which device drivers 2660 * will make derived classes. 2661 */ 2662struct gl_framebuffer 2663{ 2664 _glthread_Mutex Mutex; /**< for thread safety */ 2665 /** 2666 * If zero, this is a window system framebuffer. If non-zero, this 2667 * is a FBO framebuffer; note that for some devices (i.e. those with 2668 * a natural pixel coordinate system for FBOs that differs from the 2669 * OpenGL/Mesa coordinate system), this means that the viewport, 2670 * polygon face orientation, and polygon stipple will have to be inverted. 2671 */ 2672 GLuint Name; 2673 2674 GLint RefCount; 2675 GLboolean DeletePending; 2676 2677 /** 2678 * The framebuffer's visual. Immutable if this is a window system buffer. 2679 * Computed from attachments if user-made FBO. 2680 */ 2681 struct gl_config Visual; 2682 2683 GLboolean Initialized; 2684 2685 GLuint Width, Height; /**< size of frame buffer in pixels */ 2686 2687 /** \name Drawing bounds (Intersection of buffer size and scissor box) */ 2688 /*@{*/ 2689 GLint _Xmin, _Xmax; /**< inclusive */ 2690 GLint _Ymin, _Ymax; /**< exclusive */ 2691 /*@}*/ 2692 2693 /** \name Derived Z buffer stuff */ 2694 /*@{*/ 2695 GLuint _DepthMax; /**< Max depth buffer value */ 2696 GLfloat _DepthMaxF; /**< Float max depth buffer value */ 2697 GLfloat _MRD; /**< minimum resolvable difference in Z values */ 2698 /*@}*/ 2699 2700 /** One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */ 2701 GLenum _Status; 2702 2703 /** Integer color values */ 2704 GLboolean _IntegerColor; 2705 2706 /** Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */ 2707 struct gl_renderbuffer_attachment Attachment[BUFFER_COUNT]; 2708 2709 /* In unextended OpenGL these vars are part of the GL_COLOR_BUFFER 2710 * attribute group and GL_PIXEL attribute group, respectively. 2711 */ 2712 GLenum ColorDrawBuffer[MAX_DRAW_BUFFERS]; 2713 GLenum ColorReadBuffer; 2714 2715 /** Computed from ColorDraw/ReadBuffer above */ 2716 GLuint _NumColorDrawBuffers; 2717 GLint _ColorDrawBufferIndexes[MAX_DRAW_BUFFERS]; /**< BUFFER_x or -1 */ 2718 GLint _ColorReadBufferIndex; /* -1 = None */ 2719 struct gl_renderbuffer *_ColorDrawBuffers[MAX_DRAW_BUFFERS]; 2720 struct gl_renderbuffer *_ColorReadBuffer; 2721 2722 /** Delete this framebuffer */ 2723 void (*Delete)(struct gl_framebuffer *fb); 2724}; 2725 2726 2727/** 2728 * Precision info for shader datatypes. See glGetShaderPrecisionFormat(). 2729 */ 2730struct gl_precision 2731{ 2732 GLushort RangeMin; /**< min value exponent */ 2733 GLushort RangeMax; /**< max value exponent */ 2734 GLushort Precision; /**< number of mantissa bits */ 2735}; 2736 2737 2738/** 2739 * Limits for vertex, geometry and fragment programs/shaders. 2740 */ 2741struct gl_program_constants 2742{ 2743 /* logical limits */ 2744 GLuint MaxInstructions; 2745 GLuint MaxAluInstructions; 2746 GLuint MaxTexInstructions; 2747 GLuint MaxTexIndirections; 2748 GLuint MaxAttribs; 2749 GLuint MaxTemps; 2750 GLuint MaxAddressRegs; 2751 GLuint MaxAddressOffset; /**< [-MaxAddressOffset, MaxAddressOffset-1] */ 2752 GLuint MaxParameters; 2753 GLuint MaxLocalParams; 2754 GLuint MaxEnvParams; 2755 /* native/hardware limits */ 2756 GLuint MaxNativeInstructions; 2757 GLuint MaxNativeAluInstructions; 2758 GLuint MaxNativeTexInstructions; 2759 GLuint MaxNativeTexIndirections; 2760 GLuint MaxNativeAttribs; 2761 GLuint MaxNativeTemps; 2762 GLuint MaxNativeAddressRegs; 2763 GLuint MaxNativeParameters; 2764 /* For shaders */ 2765 GLuint MaxUniformComponents; /**< Usually == MaxParameters * 4 */ 2766 /* ES 2.0 and GL_ARB_ES2_compatibility */ 2767 struct gl_precision LowFloat, MediumFloat, HighFloat; 2768 struct gl_precision LowInt, MediumInt, HighInt; 2769 /* GL_ARB_uniform_buffer_object */ 2770 GLuint MaxUniformBlocks; 2771 GLuint MaxCombinedUniformComponents; 2772}; 2773 2774 2775/** 2776 * Constants which may be overridden by device driver during context creation 2777 * but are never changed after that. 2778 */ 2779struct gl_constants 2780{ 2781 GLint MaxTextureMbytes; /**< Max memory per image, in MB */ 2782 GLint MaxTextureLevels; /**< Max mipmap levels. */ 2783 GLint Max3DTextureLevels; /**< Max mipmap levels for 3D textures */ 2784 GLint MaxCubeTextureLevels; /**< Max mipmap levels for cube textures */ 2785 GLint MaxArrayTextureLayers; /**< Max layers in array textures */ 2786 GLint MaxTextureRectSize; /**< Max rectangle texture size, in pixes */ 2787 GLuint MaxTextureCoordUnits; 2788 GLuint MaxTextureImageUnits; 2789 GLuint MaxVertexTextureImageUnits; 2790 GLuint MaxCombinedTextureImageUnits; 2791 GLuint MaxGeometryTextureImageUnits; 2792 GLuint MaxTextureUnits; /**< = MIN(CoordUnits, ImageUnits) */ 2793 GLfloat MaxTextureMaxAnisotropy; /**< GL_EXT_texture_filter_anisotropic */ 2794 GLfloat MaxTextureLodBias; /**< GL_EXT_texture_lod_bias */ 2795 GLuint MaxTextureBufferSize; /**< GL_ARB_texture_buffer_object */ 2796 2797 GLuint MaxArrayLockSize; 2798 2799 GLint SubPixelBits; 2800 2801 GLfloat MinPointSize, MaxPointSize; /**< aliased */ 2802 GLfloat MinPointSizeAA, MaxPointSizeAA; /**< antialiased */ 2803 GLfloat PointSizeGranularity; 2804 GLfloat MinLineWidth, MaxLineWidth; /**< aliased */ 2805 GLfloat MinLineWidthAA, MaxLineWidthAA; /**< antialiased */ 2806 GLfloat LineWidthGranularity; 2807 2808 GLuint MaxColorTableSize; 2809 2810 GLuint MaxClipPlanes; 2811 GLuint MaxLights; 2812 GLfloat MaxShininess; /**< GL_NV_light_max_exponent */ 2813 GLfloat MaxSpotExponent; /**< GL_NV_light_max_exponent */ 2814 2815 GLuint MaxViewportWidth, MaxViewportHeight; 2816 2817 struct gl_program_constants VertexProgram; /**< GL_ARB_vertex_program */ 2818 struct gl_program_constants FragmentProgram; /**< GL_ARB_fragment_program */ 2819 struct gl_program_constants GeometryProgram; /**< GL_ARB_geometry_shader4 */ 2820 GLuint MaxProgramMatrices; 2821 GLuint MaxProgramMatrixStackDepth; 2822 2823 struct { 2824 GLuint SamplesPassed; 2825 GLuint TimeElapsed; 2826 GLuint Timestamp; 2827 GLuint PrimitivesGenerated; 2828 GLuint PrimitivesWritten; 2829 } QueryCounterBits; 2830 2831 /** vertex array / buffer object bounds checking */ 2832 GLboolean CheckArrayBounds; 2833 2834 GLuint MaxDrawBuffers; /**< GL_ARB_draw_buffers */ 2835 2836 GLuint MaxColorAttachments; /**< GL_EXT_framebuffer_object */ 2837 GLuint MaxRenderbufferSize; /**< GL_EXT_framebuffer_object */ 2838 GLuint MaxSamples; /**< GL_ARB_framebuffer_object */ 2839 2840 /** Number of varying vectors between vertex and fragment shaders */ 2841 GLuint MaxVarying; 2842 GLuint MaxVertexVaryingComponents; /**< Between vert and geom shader */ 2843 GLuint MaxGeometryVaryingComponents; /**< Between geom and frag shader */ 2844 2845 /** @{ 2846 * GL_ARB_uniform_buffer_object 2847 */ 2848 GLuint MaxCombinedUniformBlocks; 2849 GLuint MaxUniformBufferBindings; 2850 GLuint MaxUniformBlockSize; 2851 GLuint UniformBufferOffsetAlignment; 2852 /** @} */ 2853 2854 /** GL_ARB_geometry_shader4 */ 2855 GLuint MaxGeometryOutputVertices; 2856 GLuint MaxGeometryTotalOutputComponents; 2857 2858 GLuint GLSLVersion; /**< GLSL version supported (ex: 120 = 1.20) */ 2859 2860 /** 2861 * Changes default GLSL extension behavior from "error" to "warn". It's out 2862 * of spec, but it can make some apps work that otherwise wouldn't. 2863 */ 2864 GLboolean ForceGLSLExtensionsWarn; 2865 2866 /** 2867 * Does the driver support real 32-bit integers? (Otherwise, integers are 2868 * simulated via floats.) 2869 */ 2870 GLboolean NativeIntegers; 2871 2872 /** 2873 * If the driver supports real 32-bit integers, what integer value should be 2874 * used for boolean true in uniform uploads? (Usually 1 or ~0.) 2875 */ 2876 GLuint UniformBooleanTrue; 2877 2878 /** Which texture units support GL_ATI_envmap_bumpmap as targets */ 2879 GLbitfield SupportedBumpUnits; 2880 2881 /** 2882 * Maximum amount of time, measured in nanseconds, that the server can wait. 2883 */ 2884 GLuint64 MaxServerWaitTimeout; 2885 2886 /** GL_EXT_provoking_vertex */ 2887 GLboolean QuadsFollowProvokingVertexConvention; 2888 2889 /** OpenGL version 3.0 */ 2890 GLbitfield ContextFlags; /**< Ex: GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */ 2891 2892 /** OpenGL version 3.2 */ 2893 GLbitfield ProfileMask; /**< Mask of CONTEXT_x_PROFILE_BIT */ 2894 2895 /** GL_EXT_transform_feedback */ 2896 GLuint MaxTransformFeedbackBuffers; 2897 GLuint MaxTransformFeedbackSeparateComponents; 2898 GLuint MaxTransformFeedbackInterleavedComponents; 2899 GLuint MaxVertexStreams; 2900 2901 /** GL_EXT_gpu_shader4 */ 2902 GLint MinProgramTexelOffset, MaxProgramTexelOffset; 2903 2904 /* GL_ARB_robustness */ 2905 GLenum ResetStrategy; 2906 2907 /* GL_ARB_blend_func_extended */ 2908 GLuint MaxDualSourceDrawBuffers; 2909 2910 /** 2911 * Whether the implementation strips out and ignores texture borders. 2912 * 2913 * Many GPU hardware implementations don't support rendering with texture 2914 * borders and mipmapped textures. (Note: not static border color, but the 2915 * old 1-pixel border around each edge). Implementations then have to do 2916 * slow fallbacks to be correct, or just ignore the border and be fast but 2917 * wrong. Setting the flag strips the border off of TexImage calls, 2918 * providing "fast but wrong" at significantly reduced driver complexity. 2919 * 2920 * Texture borders are deprecated in GL 3.0. 2921 **/ 2922 GLboolean StripTextureBorder; 2923 2924 /** 2925 * For drivers which can do a better job at eliminating unused varyings 2926 * and uniforms than the GLSL compiler. 2927 * 2928 * XXX Remove these as soon as a better solution is available. 2929 */ 2930 GLboolean GLSLSkipStrictMaxVaryingLimitCheck; 2931 GLboolean GLSLSkipStrictMaxUniformLimitCheck; 2932 2933 /** 2934 * Force software support for primitive restart in the VBO module. 2935 */ 2936 GLboolean PrimitiveRestartInSoftware; 2937}; 2938 2939 2940/** 2941 * Enable flag for each OpenGL extension. Different device drivers will 2942 * enable different extensions at runtime. 2943 */ 2944struct gl_extensions 2945{ 2946 GLboolean dummy; /* don't remove this! */ 2947 GLboolean dummy_true; /* Set true by _mesa_init_extensions(). */ 2948 GLboolean dummy_false; /* Set false by _mesa_init_extensions(). */ 2949 GLboolean ARB_ES2_compatibility; 2950 GLboolean ARB_base_instance; 2951 GLboolean ARB_blend_func_extended; 2952 GLboolean ARB_color_buffer_float; 2953 GLboolean ARB_conservative_depth; 2954 GLboolean ARB_copy_buffer; 2955 GLboolean ARB_depth_buffer_float; 2956 GLboolean ARB_depth_clamp; 2957 GLboolean ARB_depth_texture; 2958 GLboolean ARB_draw_buffers_blend; 2959 GLboolean ARB_draw_elements_base_vertex; 2960 GLboolean ARB_draw_instanced; 2961 GLboolean ARB_fragment_coord_conventions; 2962 GLboolean ARB_fragment_program; 2963 GLboolean ARB_fragment_program_shadow; 2964 GLboolean ARB_fragment_shader; 2965 GLboolean ARB_framebuffer_object; 2966 GLboolean ARB_explicit_attrib_location; 2967 GLboolean ARB_geometry_shader4; 2968 GLboolean ARB_half_float_pixel; 2969 GLboolean ARB_half_float_vertex; 2970 GLboolean ARB_instanced_arrays; 2971 GLboolean ARB_map_buffer_range; 2972 GLboolean ARB_occlusion_query; 2973 GLboolean ARB_occlusion_query2; 2974 GLboolean ARB_point_sprite; 2975 GLboolean ARB_seamless_cube_map; 2976 GLboolean ARB_shader_bit_encoding; 2977 GLboolean ARB_shader_objects; 2978 GLboolean ARB_shader_stencil_export; 2979 GLboolean ARB_shader_texture_lod; 2980 GLboolean ARB_shading_language_100; 2981 GLboolean ARB_shadow; 2982 GLboolean ARB_sync; 2983 GLboolean ARB_texture_border_clamp; 2984 GLboolean ARB_texture_buffer_object; 2985 GLboolean ARB_texture_compression_rgtc; 2986 GLboolean ARB_texture_cube_map; 2987 GLboolean ARB_texture_env_combine; 2988 GLboolean ARB_texture_env_crossbar; 2989 GLboolean ARB_texture_env_dot3; 2990 GLboolean ARB_texture_float; 2991 GLboolean ARB_texture_multisample; 2992 GLboolean ARB_texture_non_power_of_two; 2993 GLboolean ARB_texture_rg; 2994 GLboolean ARB_texture_rgb10_a2ui; 2995 GLboolean ARB_texture_storage; 2996 GLboolean ARB_timer_query; 2997 GLboolean ARB_transform_feedback2; 2998 GLboolean ARB_transform_feedback3; 2999 GLboolean ARB_transform_feedback_instanced; 3000 GLboolean ARB_transpose_matrix; 3001 GLboolean ARB_uniform_buffer_object; 3002 GLboolean ARB_vertex_program; 3003 GLboolean ARB_vertex_shader; 3004 GLboolean ARB_vertex_type_2_10_10_10_rev; 3005 GLboolean ARB_window_pos; 3006 GLboolean EXT_blend_color; 3007 GLboolean EXT_blend_equation_separate; 3008 GLboolean EXT_blend_func_separate; 3009 GLboolean EXT_blend_minmax; 3010 GLboolean EXT_clip_volume_hint; 3011 GLboolean EXT_compiled_vertex_array; 3012 GLboolean EXT_depth_bounds_test; 3013 GLboolean EXT_draw_buffers2; 3014 GLboolean EXT_draw_range_elements; 3015 GLboolean EXT_fog_coord; 3016 GLboolean EXT_framebuffer_blit; 3017 GLboolean EXT_framebuffer_multisample; 3018 GLboolean EXT_framebuffer_object; 3019 GLboolean EXT_framebuffer_sRGB; 3020 GLboolean EXT_gpu_program_parameters; 3021 GLboolean EXT_gpu_shader4; 3022 GLboolean EXT_packed_depth_stencil; 3023 GLboolean EXT_packed_float; 3024 GLboolean EXT_packed_pixels; 3025 GLboolean EXT_pixel_buffer_object; 3026 GLboolean EXT_point_parameters; 3027 GLboolean EXT_provoking_vertex; 3028 GLboolean EXT_rescale_normal; 3029 GLboolean EXT_shadow_funcs; 3030 GLboolean EXT_secondary_color; 3031 GLboolean EXT_separate_shader_objects; 3032 GLboolean EXT_separate_specular_color; 3033 GLboolean EXT_stencil_two_side; 3034 GLboolean EXT_texture3D; 3035 GLboolean EXT_texture_array; 3036 GLboolean EXT_texture_compression_latc; 3037 GLboolean EXT_texture_compression_s3tc; 3038 GLboolean EXT_texture_env_dot3; 3039 GLboolean EXT_texture_filter_anisotropic; 3040 GLboolean EXT_texture_integer; 3041 GLboolean EXT_texture_mirror_clamp; 3042 GLboolean EXT_texture_shared_exponent; 3043 GLboolean EXT_texture_snorm; 3044 GLboolean EXT_texture_sRGB; 3045 GLboolean EXT_texture_sRGB_decode; 3046 GLboolean EXT_texture_swizzle; 3047 GLboolean EXT_transform_feedback; 3048 GLboolean EXT_timer_query; 3049 GLboolean EXT_vertex_array_bgra; 3050 GLboolean OES_standard_derivatives; 3051 /* vendor extensions */ 3052 GLboolean AMD_seamless_cubemap_per_texture; 3053 GLboolean APPLE_packed_pixels; 3054 GLboolean APPLE_object_purgeable; 3055 GLboolean ATI_envmap_bumpmap; 3056 GLboolean ATI_texture_compression_3dc; 3057 GLboolean ATI_texture_mirror_once; 3058 GLboolean ATI_texture_env_combine3; 3059 GLboolean ATI_fragment_shader; 3060 GLboolean ATI_separate_stencil; 3061 GLboolean IBM_rasterpos_clip; 3062 GLboolean IBM_multimode_draw_arrays; 3063 GLboolean MESA_pack_invert; 3064 GLboolean MESA_resize_buffers; 3065 GLboolean MESA_ycbcr_texture; 3066 GLboolean MESA_texture_array; 3067 GLboolean NV_blend_square; 3068 GLboolean NV_conditional_render; 3069 GLboolean NV_fog_distance; 3070 GLboolean NV_fragment_program; 3071 GLboolean NV_fragment_program_option; 3072 GLboolean NV_light_max_exponent; 3073 GLboolean NV_point_sprite; 3074 GLboolean NV_primitive_restart; 3075 GLboolean NV_read_buffer; 3076 GLboolean NV_texture_barrier; 3077 GLboolean NV_texgen_reflection; 3078 GLboolean NV_texture_env_combine4; 3079 GLboolean NV_texture_rectangle; 3080 GLboolean NV_vertex_program; 3081 GLboolean NV_vertex_program1_1; 3082 GLboolean SGIS_texture_lod; 3083 GLboolean TDFX_texture_compression_FXT1; 3084 GLboolean S3_s3tc; 3085 GLboolean OES_EGL_image; 3086 GLboolean OES_draw_texture; 3087 GLboolean OES_EGL_image_external; 3088 GLboolean OES_compressed_ETC1_RGB8_texture; 3089 GLboolean extension_sentinel; 3090 /** The extension string */ 3091 const GLubyte *String; 3092 /** Number of supported extensions */ 3093 GLuint Count; 3094}; 3095 3096 3097/** 3098 * A stack of matrices (projection, modelview, color, texture, etc). 3099 */ 3100struct gl_matrix_stack 3101{ 3102 GLmatrix *Top; /**< points into Stack */ 3103 GLmatrix *Stack; /**< array [MaxDepth] of GLmatrix */ 3104 GLuint Depth; /**< 0 <= Depth < MaxDepth */ 3105 GLuint MaxDepth; /**< size of Stack[] array */ 3106 GLuint DirtyFlag; /**< _NEW_MODELVIEW or _NEW_PROJECTION, for example */ 3107}; 3108 3109 3110/** 3111 * \name Bits for image transfer operations 3112 * \sa __struct gl_contextRec::ImageTransferState. 3113 */ 3114/*@{*/ 3115#define IMAGE_SCALE_BIAS_BIT 0x1 3116#define IMAGE_SHIFT_OFFSET_BIT 0x2 3117#define IMAGE_MAP_COLOR_BIT 0x4 3118#define IMAGE_CLAMP_BIT 0x800 3119 3120 3121/** Pixel Transfer ops */ 3122#define IMAGE_BITS (IMAGE_SCALE_BIAS_BIT | \ 3123 IMAGE_SHIFT_OFFSET_BIT | \ 3124 IMAGE_MAP_COLOR_BIT) 3125 3126/** 3127 * \name Bits to indicate what state has changed. 3128 */ 3129/*@{*/ 3130#define _NEW_MODELVIEW (1 << 0) /**< gl_context::ModelView */ 3131#define _NEW_PROJECTION (1 << 1) /**< gl_context::Projection */ 3132#define _NEW_TEXTURE_MATRIX (1 << 2) /**< gl_context::TextureMatrix */ 3133#define _NEW_COLOR (1 << 3) /**< gl_context::Color */ 3134#define _NEW_DEPTH (1 << 4) /**< gl_context::Depth */ 3135#define _NEW_EVAL (1 << 5) /**< gl_context::Eval, EvalMap */ 3136#define _NEW_FOG (1 << 6) /**< gl_context::Fog */ 3137#define _NEW_HINT (1 << 7) /**< gl_context::Hint */ 3138#define _NEW_LIGHT (1 << 8) /**< gl_context::Light */ 3139#define _NEW_LINE (1 << 9) /**< gl_context::Line */ 3140#define _NEW_PIXEL (1 << 10) /**< gl_context::Pixel */ 3141#define _NEW_POINT (1 << 11) /**< gl_context::Point */ 3142#define _NEW_POLYGON (1 << 12) /**< gl_context::Polygon */ 3143#define _NEW_POLYGONSTIPPLE (1 << 13) /**< gl_context::PolygonStipple */ 3144#define _NEW_SCISSOR (1 << 14) /**< gl_context::Scissor */ 3145#define _NEW_STENCIL (1 << 15) /**< gl_context::Stencil */ 3146#define _NEW_TEXTURE (1 << 16) /**< gl_context::Texture */ 3147#define _NEW_TRANSFORM (1 << 17) /**< gl_context::Transform */ 3148#define _NEW_VIEWPORT (1 << 18) /**< gl_context::Viewport */ 3149#define _NEW_PACKUNPACK (1 << 19) /**< gl_context::Pack, Unpack */ 3150#define _NEW_ARRAY (1 << 20) /**< gl_context::Array */ 3151#define _NEW_RENDERMODE (1 << 21) /**< gl_context::RenderMode, etc */ 3152#define _NEW_BUFFERS (1 << 22) /**< gl_context::Visual, DrawBuffer, */ 3153#define _NEW_CURRENT_ATTRIB (1 << 23) /**< gl_context::Current */ 3154#define _NEW_MULTISAMPLE (1 << 24) /**< gl_context::Multisample */ 3155#define _NEW_TRACK_MATRIX (1 << 25) /**< gl_context::VertexProgram */ 3156#define _NEW_PROGRAM (1 << 26) /**< New program/shader state */ 3157#define _NEW_PROGRAM_CONSTANTS (1 << 27) 3158#define _NEW_BUFFER_OBJECT (1 << 28) 3159#define _NEW_FRAG_CLAMP (1 << 29) 3160#define _NEW_TRANSFORM_FEEDBACK (1 << 30) /**< gl_context::TransformFeedback */ 3161#define _NEW_VARYING_VP_INPUTS (1 << 31) /**< gl_context::varying_vp_inputs */ 3162#define _NEW_ALL ~0 3163 3164/** 3165 * We use _NEW_TRANSFORM for GL_RASTERIZER_DISCARD. This #define is for 3166 * clarity. 3167 */ 3168#define _NEW_RASTERIZER_DISCARD _NEW_TRANSFORM 3169/*@}*/ 3170 3171 3172/** 3173 * \name A bunch of flags that we think might be useful to drivers. 3174 * 3175 * Set in the __struct gl_contextRec::_TriangleCaps bitfield. 3176 */ 3177/*@{*/ 3178#define DD_SEPARATE_SPECULAR (1 << 0) 3179#define DD_TRI_LIGHT_TWOSIDE (1 << 1) 3180#define DD_TRI_UNFILLED (1 << 2) 3181#define DD_TRI_SMOOTH (1 << 3) 3182#define DD_TRI_STIPPLE (1 << 4) 3183#define DD_TRI_OFFSET (1 << 5) 3184#define DD_LINE_SMOOTH (1 << 6) 3185#define DD_LINE_STIPPLE (1 << 7) 3186#define DD_POINT_SMOOTH (1 << 8) 3187#define DD_POINT_ATTEN (1 << 9) 3188/*@}*/ 3189 3190 3191/** 3192 * Composite state flags 3193 */ 3194/*@{*/ 3195#define _MESA_NEW_NEED_EYE_COORDS (_NEW_LIGHT | \ 3196 _NEW_TEXTURE | \ 3197 _NEW_POINT | \ 3198 _NEW_PROGRAM | \ 3199 _NEW_MODELVIEW) 3200 3201#define _MESA_NEW_SEPARATE_SPECULAR (_NEW_LIGHT | \ 3202 _NEW_FOG | \ 3203 _NEW_PROGRAM) 3204 3205 3206/*@}*/ 3207 3208 3209 3210 3211/* This has to be included here. */ 3212#include "dd.h" 3213 3214 3215/** 3216 * Display list flags. 3217 * Strictly this is a tnl-private concept, but it doesn't seem 3218 * worthwhile adding a tnl private structure just to hold this one bit 3219 * of information: 3220 */ 3221#define DLIST_DANGLING_REFS 0x1 3222 3223 3224/** Opaque declaration of display list payload data type */ 3225union gl_dlist_node; 3226 3227 3228/** 3229 * Provide a location where information about a display list can be 3230 * collected. Could be extended with driverPrivate structures, 3231 * etc. in the future. 3232 */ 3233struct gl_display_list 3234{ 3235 GLuint Name; 3236 GLbitfield Flags; /**< DLIST_x flags */ 3237 /** The dlist commands are in a linked list of nodes */ 3238 union gl_dlist_node *Head; 3239}; 3240 3241 3242/** 3243 * State used during display list compilation and execution. 3244 */ 3245struct gl_dlist_state 3246{ 3247 GLuint CallDepth; /**< Current recursion calling depth */ 3248 3249 struct gl_display_list *CurrentList; /**< List currently being compiled */ 3250 union gl_dlist_node *CurrentBlock; /**< Pointer to current block of nodes */ 3251 GLuint CurrentPos; /**< Index into current block of nodes */ 3252 3253 GLvertexformat ListVtxfmt; 3254 3255 GLubyte ActiveAttribSize[VERT_ATTRIB_MAX]; 3256 GLfloat CurrentAttrib[VERT_ATTRIB_MAX][4]; 3257 3258 GLubyte ActiveMaterialSize[MAT_ATTRIB_MAX]; 3259 GLfloat CurrentMaterial[MAT_ATTRIB_MAX][4]; 3260 3261 struct { 3262 /* State known to have been set by the currently-compiling display 3263 * list. Used to eliminate some redundant state changes. 3264 */ 3265 GLenum ShadeModel; 3266 } Current; 3267}; 3268 3269/** 3270 * An error, warning, or other piece of debug information for an application 3271 * to consume via GL_ARB_debug_output. 3272 */ 3273struct gl_debug_msg 3274{ 3275 GLenum source; 3276 GLenum type; 3277 GLuint id; 3278 GLenum severity; 3279 GLsizei length; 3280 GLcharARB *message; 3281}; 3282 3283typedef enum { 3284 API_ERROR_UNKNOWN, 3285 API_ERROR_COUNT 3286} gl_api_error; 3287 3288typedef enum { 3289 WINSYS_ERROR_UNKNOWN, 3290 WINSYS_ERROR_COUNT 3291} gl_winsys_error; 3292 3293typedef enum { 3294 SHADER_ERROR_UNKNOWN, 3295 SHADER_ERROR_COUNT 3296} gl_shader_error; 3297 3298typedef enum { 3299 OTHER_ERROR_UNKNOWN, 3300 OTHER_ERROR_OUT_OF_MEMORY, 3301 OTHER_ERROR_COUNT 3302} gl_other_error; 3303 3304struct gl_client_namespace 3305{ 3306 struct _mesa_HashTable *IDs; 3307 unsigned ZeroID; /* a HashTable won't take zero, so store its state here */ 3308 struct simple_node Severity[3]; /* lists of IDs in the hash table */ 3309}; 3310 3311struct gl_client_debug 3312{ 3313 GLboolean Defaults[3][2][6]; /* severity, source, type */ 3314 struct gl_client_namespace Namespaces[2][6]; /* source, type */ 3315}; 3316 3317struct gl_debug_state 3318{ 3319 GLDEBUGPROCARB Callback; 3320 GLvoid *CallbackData; 3321 GLboolean SyncOutput; 3322 GLboolean ApiErrors[API_ERROR_COUNT]; 3323 GLboolean WinsysErrors[WINSYS_ERROR_COUNT]; 3324 GLboolean ShaderErrors[SHADER_ERROR_COUNT]; 3325 GLboolean OtherErrors[OTHER_ERROR_COUNT]; 3326 struct gl_client_debug ClientIDs; 3327 struct gl_debug_msg Log[MAX_DEBUG_LOGGED_MESSAGES]; 3328 GLint NumMessages; 3329 GLint NextMsg; 3330 GLint NextMsgLength; /* redundant, but copied here from Log[NextMsg].length 3331 for the sake of the offsetof() code in get.c */ 3332}; 3333 3334/** 3335 * Enum for the OpenGL APIs we know about and may support. 3336 */ 3337typedef enum 3338{ 3339 API_OPENGL, /* legacy / compatibility contexts */ 3340 API_OPENGLES, 3341 API_OPENGLES2, 3342 API_OPENGL_CORE, 3343 3344 API_LAST = API_OPENGL_CORE, 3345} gl_api; 3346 3347/** 3348 * Driver-specific state flags. 3349 * 3350 * These are or'd with gl_context::NewDriverState to notify a driver about 3351 * a state change. The driver sets the flags at context creation and 3352 * the meaning of the bits set is opaque to core Mesa. 3353 */ 3354struct gl_driver_flags 3355{ 3356 GLbitfield NewArray; /**< Vertex array state */ 3357}; 3358 3359struct gl_uniform_buffer_binding 3360{ 3361 struct gl_buffer_object *BufferObject; 3362 /** Start of uniform block data in the buffer */ 3363 GLintptr Offset; 3364 /** Size of data allowed to be referenced from the buffer (in bytes) */ 3365 GLsizeiptr Size; 3366 /** 3367 * glBindBufferBase() indicates that the Size should be ignored and only 3368 * limited by the current size of the BufferObject. 3369 */ 3370 GLboolean AutomaticSize; 3371}; 3372 3373/** 3374 * Mesa rendering context. 3375 * 3376 * This is the central context data structure for Mesa. Almost all 3377 * OpenGL state is contained in this structure. 3378 * Think of this as a base class from which device drivers will derive 3379 * sub classes. 3380 * 3381 * The struct gl_context typedef names this structure. 3382 */ 3383struct gl_context 3384{ 3385 /** State possibly shared with other contexts in the address space */ 3386 struct gl_shared_state *Shared; 3387 3388 /** \name API function pointer tables */ 3389 /*@{*/ 3390 gl_api API; 3391 struct _glapi_table *Save; /**< Display list save functions */ 3392 struct _glapi_table *Exec; /**< Execute functions */ 3393 struct _glapi_table *CurrentDispatch; /**< == Save or Exec !! */ 3394 /*@}*/ 3395 3396 struct gl_config Visual; 3397 struct gl_framebuffer *DrawBuffer; /**< buffer for writing */ 3398 struct gl_framebuffer *ReadBuffer; /**< buffer for reading */ 3399 struct gl_framebuffer *WinSysDrawBuffer; /**< set with MakeCurrent */ 3400 struct gl_framebuffer *WinSysReadBuffer; /**< set with MakeCurrent */ 3401 3402 /** 3403 * Device driver function pointer table 3404 */ 3405 struct dd_function_table Driver; 3406 3407 void *DriverCtx; /**< Points to device driver context/state */ 3408 3409 /** Core/Driver constants */ 3410 struct gl_constants Const; 3411 3412 /** \name The various 4x4 matrix stacks */ 3413 /*@{*/ 3414 struct gl_matrix_stack ModelviewMatrixStack; 3415 struct gl_matrix_stack ProjectionMatrixStack; 3416 struct gl_matrix_stack TextureMatrixStack[MAX_TEXTURE_UNITS]; 3417 struct gl_matrix_stack ProgramMatrixStack[MAX_PROGRAM_MATRICES]; 3418 struct gl_matrix_stack *CurrentStack; /**< Points to one of the above stacks */ 3419 /*@}*/ 3420 3421 /** Combined modelview and projection matrix */ 3422 GLmatrix _ModelProjectMatrix; 3423 3424 /** \name Display lists */ 3425 struct gl_dlist_state ListState; 3426 3427 GLboolean ExecuteFlag; /**< Execute GL commands? */ 3428 GLboolean CompileFlag; /**< Compile GL commands into display list? */ 3429 3430 /** Extension information */ 3431 struct gl_extensions Extensions; 3432 3433 /** GL version integer, for example 31 for GL 3.1, or 20 for GLES 2.0. */ 3434 GLuint Version; 3435 char *VersionString; 3436 3437 /** \name State attribute stack (for glPush/PopAttrib) */ 3438 /*@{*/ 3439 GLuint AttribStackDepth; 3440 struct gl_attrib_node *AttribStack[MAX_ATTRIB_STACK_DEPTH]; 3441 /*@}*/ 3442 3443 /** \name Renderer attribute groups 3444 * 3445 * We define a struct for each attribute group to make pushing and popping 3446 * attributes easy. Also it's a good organization. 3447 */ 3448 /*@{*/ 3449 struct gl_accum_attrib Accum; /**< Accum buffer attributes */ 3450 struct gl_colorbuffer_attrib Color; /**< Color buffer attributes */ 3451 struct gl_current_attrib Current; /**< Current attributes */ 3452 struct gl_depthbuffer_attrib Depth; /**< Depth buffer attributes */ 3453 struct gl_eval_attrib Eval; /**< Eval attributes */ 3454 struct gl_fog_attrib Fog; /**< Fog attributes */ 3455 struct gl_hint_attrib Hint; /**< Hint attributes */ 3456 struct gl_light_attrib Light; /**< Light attributes */ 3457 struct gl_line_attrib Line; /**< Line attributes */ 3458 struct gl_list_attrib List; /**< List attributes */ 3459 struct gl_multisample_attrib Multisample; 3460 struct gl_pixel_attrib Pixel; /**< Pixel attributes */ 3461 struct gl_point_attrib Point; /**< Point attributes */ 3462 struct gl_polygon_attrib Polygon; /**< Polygon attributes */ 3463 GLuint PolygonStipple[32]; /**< Polygon stipple */ 3464 struct gl_scissor_attrib Scissor; /**< Scissor attributes */ 3465 struct gl_stencil_attrib Stencil; /**< Stencil buffer attributes */ 3466 struct gl_texture_attrib Texture; /**< Texture attributes */ 3467 struct gl_transform_attrib Transform; /**< Transformation attributes */ 3468 struct gl_viewport_attrib Viewport; /**< Viewport attributes */ 3469 /*@}*/ 3470 3471 /** \name Client attribute stack */ 3472 /*@{*/ 3473 GLuint ClientAttribStackDepth; 3474 struct gl_attrib_node *ClientAttribStack[MAX_CLIENT_ATTRIB_STACK_DEPTH]; 3475 /*@}*/ 3476 3477 /** \name Client attribute groups */ 3478 /*@{*/ 3479 struct gl_array_attrib Array; /**< Vertex arrays */ 3480 struct gl_pixelstore_attrib Pack; /**< Pixel packing */ 3481 struct gl_pixelstore_attrib Unpack; /**< Pixel unpacking */ 3482 struct gl_pixelstore_attrib DefaultPacking; /**< Default params */ 3483 /*@}*/ 3484 3485 /** \name Other assorted state (not pushed/popped on attribute stack) */ 3486 /*@{*/ 3487 struct gl_pixelmaps PixelMaps; 3488 3489 struct gl_evaluators EvalMap; /**< All evaluators */ 3490 struct gl_feedback Feedback; /**< Feedback */ 3491 struct gl_selection Select; /**< Selection */ 3492 3493 struct gl_program_state Program; /**< general program state */ 3494 struct gl_vertex_program_state VertexProgram; 3495 struct gl_fragment_program_state FragmentProgram; 3496 struct gl_geometry_program_state GeometryProgram; 3497 struct gl_ati_fragment_shader_state ATIFragmentShader; 3498 3499 struct gl_shader_state Shader; /**< GLSL shader object state */ 3500 struct gl_shader_compiler_options ShaderCompilerOptions[MESA_SHADER_TYPES]; 3501 3502 struct gl_query_state Query; /**< occlusion, timer queries */ 3503 3504 struct gl_transform_feedback_state TransformFeedback; 3505 3506 struct gl_buffer_object *CopyReadBuffer; /**< GL_ARB_copy_buffer */ 3507 struct gl_buffer_object *CopyWriteBuffer; /**< GL_ARB_copy_buffer */ 3508 3509 /** 3510 * Current GL_ARB_uniform_buffer_object binding referenced by 3511 * GL_UNIFORM_BUFFER target for glBufferData, glMapBuffer, etc. 3512 */ 3513 struct gl_buffer_object *UniformBuffer; 3514 3515 /** 3516 * Array of uniform buffers for GL_ARB_uniform_buffer_object and GL 3.1. 3517 * This is set up using glBindBufferRange() or glBindBufferBase(). They are 3518 * associated with uniform blocks by glUniformBlockBinding()'s state in the 3519 * shader program. 3520 */ 3521 struct gl_uniform_buffer_binding *UniformBufferBindings; 3522 3523 /*@}*/ 3524 3525 struct gl_meta_state *Meta; /**< for "meta" operations */ 3526 3527 /* GL_EXT_framebuffer_object */ 3528 struct gl_renderbuffer *CurrentRenderbuffer; 3529 3530 GLenum ErrorValue; /**< Last error code */ 3531 3532 /* GL_ARB_robustness */ 3533 GLenum ResetStatus; 3534 3535 /** 3536 * Recognize and silence repeated error debug messages in buggy apps. 3537 */ 3538 const char *ErrorDebugFmtString; 3539 GLuint ErrorDebugCount; 3540 3541 /* GL_ARB_debug_output */ 3542 struct gl_debug_state Debug; 3543 3544 GLenum RenderMode; /**< either GL_RENDER, GL_SELECT, GL_FEEDBACK */ 3545 GLbitfield NewState; /**< bitwise-or of _NEW_* flags */ 3546 GLbitfield NewDriverState;/**< bitwise-or of flags from DriverFlags */ 3547 3548 struct gl_driver_flags DriverFlags; 3549 3550 GLboolean ViewportInitialized; /**< has viewport size been initialized? */ 3551 3552 GLbitfield64 varying_vp_inputs; /**< mask of VERT_BIT_* flags */ 3553 3554 /** \name Derived state */ 3555 /*@{*/ 3556 /** Bitwise-or of DD_* flags. Note that this bitfield may be used before 3557 * state validation so they need to always be current. 3558 */ 3559 GLbitfield _TriangleCaps; 3560 GLbitfield _ImageTransferState;/**< bitwise-or of IMAGE_*_BIT flags */ 3561 GLfloat _EyeZDir[3]; 3562 GLfloat _ModelViewInvScale; 3563 GLboolean _NeedEyeCoords; 3564 GLboolean _ForceEyeCoords; 3565 3566 GLuint TextureStateTimestamp; /**< detect changes to shared state */ 3567 3568 struct gl_list_extensions *ListExt; /**< driver dlist extensions */ 3569 3570 /** \name For debugging/development only */ 3571 /*@{*/ 3572 GLboolean FirstTimeCurrent; 3573 /*@}*/ 3574 3575 /** software compression/decompression supported or not */ 3576 GLboolean Mesa_DXTn; 3577 3578 GLboolean TextureFormatSupported[MESA_FORMAT_COUNT]; 3579 3580 /** 3581 * Use dp4 (rather than mul/mad) instructions for position 3582 * transformation? 3583 */ 3584 GLboolean mvp_with_dp4; 3585 3586 GLboolean RasterDiscard; /**< GL_RASTERIZER_DISCARD */ 3587 3588 /** 3589 * \name Hooks for module contexts. 3590 * 3591 * These will eventually live in the driver or elsewhere. 3592 */ 3593 /*@{*/ 3594 void *swrast_context; 3595 void *swsetup_context; 3596 void *swtnl_context; 3597 void *swtnl_im; 3598 struct st_context *st; 3599 void *aelt_context; 3600 /*@}*/ 3601}; 3602 3603 3604#ifdef DEBUG 3605extern int MESA_VERBOSE; 3606extern int MESA_DEBUG_FLAGS; 3607# define MESA_FUNCTION __FUNCTION__ 3608#else 3609# define MESA_VERBOSE 0 3610# define MESA_DEBUG_FLAGS 0 3611# define MESA_FUNCTION "a function" 3612# ifndef NDEBUG 3613# define NDEBUG 3614# endif 3615#endif 3616 3617 3618/** The MESA_VERBOSE var is a bitmask of these flags */ 3619enum _verbose 3620{ 3621 VERBOSE_VARRAY = 0x0001, 3622 VERBOSE_TEXTURE = 0x0002, 3623 VERBOSE_MATERIAL = 0x0004, 3624 VERBOSE_PIPELINE = 0x0008, 3625 VERBOSE_DRIVER = 0x0010, 3626 VERBOSE_STATE = 0x0020, 3627 VERBOSE_API = 0x0040, 3628 VERBOSE_DISPLAY_LIST = 0x0100, 3629 VERBOSE_LIGHTING = 0x0200, 3630 VERBOSE_PRIMS = 0x0400, 3631 VERBOSE_VERTS = 0x0800, 3632 VERBOSE_DISASSEM = 0x1000, 3633 VERBOSE_DRAW = 0x2000, 3634 VERBOSE_SWAPBUFFERS = 0x4000 3635}; 3636 3637 3638/** The MESA_DEBUG_FLAGS var is a bitmask of these flags */ 3639enum _debug 3640{ 3641 DEBUG_SILENT = (1 << 0), 3642 DEBUG_ALWAYS_FLUSH = (1 << 1), 3643 DEBUG_INCOMPLETE_TEXTURE = (1 << 2), 3644 DEBUG_INCOMPLETE_FBO = (1 << 3) 3645}; 3646 3647 3648 3649#ifdef __cplusplus 3650} 3651#endif 3652 3653#endif /* MTYPES_H */ 3654