1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 5 * Copyright (C) 2009 VMware, Inc. All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * 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 <stdint.h> /* uint32_t */ 38 #include <stdbool.h> 39 #include "c11/threads.h" 40 41 #include "main/glheader.h" 42 #include "main/config.h" 43 #include "glapi/glapi.h" 44 #include "math/m_matrix.h" /* GLmatrix */ 45 #include "compiler/shader_enums.h" 46 #include "compiler/shader_info.h" 47 #include "main/formats.h" /* MESA_FORMAT_COUNT */ 48 #include "compiler/glsl/list.h" 49 #include "util/bitscan.h" 50 51 52 #ifdef __cplusplus 53 extern "C" { 54 #endif 55 56 57 /** 58 * \name 64-bit extension of GLbitfield. 59 */ 60 /*@{*/ 61 typedef GLuint64 GLbitfield64; 62 63 /** Set a single bit */ 64 #define BITFIELD64_BIT(b) ((GLbitfield64)1 << (b)) 65 /** Set all bits up to excluding bit b */ 66 #define BITFIELD64_MASK(b) \ 67 ((b) == 64 ? (~(GLbitfield64)0) : BITFIELD64_BIT(b) - 1) 68 /** Set count bits starting from bit b */ 69 #define BITFIELD64_RANGE(b, count) \ 70 (BITFIELD64_MASK((b) + (count)) & ~BITFIELD64_MASK(b)) 71 72 73 /** 74 * \name Some forward type declarations 75 */ 76 /*@{*/ 77 struct _mesa_HashTable; 78 struct gl_attrib_node; 79 struct gl_list_extensions; 80 struct gl_meta_state; 81 struct gl_program_cache; 82 struct gl_texture_object; 83 struct gl_debug_state; 84 struct gl_context; 85 struct st_context; 86 struct gl_uniform_storage; 87 struct prog_instruction; 88 struct gl_program_parameter_list; 89 struct set; 90 struct set_entry; 91 struct vbo_context; 92 /*@}*/ 93 94 95 /** Extra draw modes beyond GL_POINTS, GL_TRIANGLE_FAN, etc */ 96 #define PRIM_MAX GL_PATCHES 97 #define PRIM_OUTSIDE_BEGIN_END (PRIM_MAX + 1) 98 #define PRIM_UNKNOWN (PRIM_MAX + 2) 99 100 /** 101 * Determine if the given gl_varying_slot appears in the fragment shader. 102 */ 103 static inline GLboolean 104 _mesa_varying_slot_in_fs(gl_varying_slot slot) 105 { 106 switch (slot) { 107 case VARYING_SLOT_PSIZ: 108 case VARYING_SLOT_BFC0: 109 case VARYING_SLOT_BFC1: 110 case VARYING_SLOT_EDGE: 111 case VARYING_SLOT_CLIP_VERTEX: 112 case VARYING_SLOT_LAYER: 113 case VARYING_SLOT_TESS_LEVEL_OUTER: 114 case VARYING_SLOT_TESS_LEVEL_INNER: 115 case VARYING_SLOT_BOUNDING_BOX0: 116 case VARYING_SLOT_BOUNDING_BOX1: 117 return GL_FALSE; 118 default: 119 return GL_TRUE; 120 } 121 } 122 123 /** 124 * Indexes for all renderbuffers 125 */ 126 typedef enum 127 { 128 /* the four standard color buffers */ 129 BUFFER_FRONT_LEFT, 130 BUFFER_BACK_LEFT, 131 BUFFER_FRONT_RIGHT, 132 BUFFER_BACK_RIGHT, 133 BUFFER_DEPTH, 134 BUFFER_STENCIL, 135 BUFFER_ACCUM, 136 /* optional aux buffer */ 137 BUFFER_AUX0, 138 /* generic renderbuffers */ 139 BUFFER_COLOR0, 140 BUFFER_COLOR1, 141 BUFFER_COLOR2, 142 BUFFER_COLOR3, 143 BUFFER_COLOR4, 144 BUFFER_COLOR5, 145 BUFFER_COLOR6, 146 BUFFER_COLOR7, 147 BUFFER_COUNT 148 } gl_buffer_index; 149 150 /** 151 * Bit flags for all renderbuffers 152 */ 153 #define BUFFER_BIT_FRONT_LEFT (1 << BUFFER_FRONT_LEFT) 154 #define BUFFER_BIT_BACK_LEFT (1 << BUFFER_BACK_LEFT) 155 #define BUFFER_BIT_FRONT_RIGHT (1 << BUFFER_FRONT_RIGHT) 156 #define BUFFER_BIT_BACK_RIGHT (1 << BUFFER_BACK_RIGHT) 157 #define BUFFER_BIT_AUX0 (1 << BUFFER_AUX0) 158 #define BUFFER_BIT_AUX1 (1 << BUFFER_AUX1) 159 #define BUFFER_BIT_AUX2 (1 << BUFFER_AUX2) 160 #define BUFFER_BIT_AUX3 (1 << BUFFER_AUX3) 161 #define BUFFER_BIT_DEPTH (1 << BUFFER_DEPTH) 162 #define BUFFER_BIT_STENCIL (1 << BUFFER_STENCIL) 163 #define BUFFER_BIT_ACCUM (1 << BUFFER_ACCUM) 164 #define BUFFER_BIT_COLOR0 (1 << BUFFER_COLOR0) 165 #define BUFFER_BIT_COLOR1 (1 << BUFFER_COLOR1) 166 #define BUFFER_BIT_COLOR2 (1 << BUFFER_COLOR2) 167 #define BUFFER_BIT_COLOR3 (1 << BUFFER_COLOR3) 168 #define BUFFER_BIT_COLOR4 (1 << BUFFER_COLOR4) 169 #define BUFFER_BIT_COLOR5 (1 << BUFFER_COLOR5) 170 #define BUFFER_BIT_COLOR6 (1 << BUFFER_COLOR6) 171 #define BUFFER_BIT_COLOR7 (1 << BUFFER_COLOR7) 172 173 /** 174 * Mask of all the color buffer bits (but not accum). 175 */ 176 #define BUFFER_BITS_COLOR (BUFFER_BIT_FRONT_LEFT | \ 177 BUFFER_BIT_BACK_LEFT | \ 178 BUFFER_BIT_FRONT_RIGHT | \ 179 BUFFER_BIT_BACK_RIGHT | \ 180 BUFFER_BIT_AUX0 | \ 181 BUFFER_BIT_COLOR0 | \ 182 BUFFER_BIT_COLOR1 | \ 183 BUFFER_BIT_COLOR2 | \ 184 BUFFER_BIT_COLOR3 | \ 185 BUFFER_BIT_COLOR4 | \ 186 BUFFER_BIT_COLOR5 | \ 187 BUFFER_BIT_COLOR6 | \ 188 BUFFER_BIT_COLOR7) 189 190 /** 191 * Framebuffer configuration (aka visual / pixelformat) 192 * Note: some of these fields should be boolean, but it appears that 193 * code in drivers/dri/common/util.c requires int-sized fields. 194 */ 195 struct gl_config 196 { 197 GLboolean rgbMode; 198 GLboolean floatMode; 199 GLuint doubleBufferMode; 200 GLuint stereoMode; 201 202 GLboolean haveAccumBuffer; 203 GLboolean haveDepthBuffer; 204 GLboolean haveStencilBuffer; 205 206 GLint redBits, greenBits, blueBits, alphaBits; /* bits per comp */ 207 GLuint redMask, greenMask, blueMask, alphaMask; 208 GLint rgbBits; /* total bits for rgb */ 209 GLint indexBits; /* total bits for colorindex */ 210 211 GLint accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits; 212 GLint depthBits; 213 GLint stencilBits; 214 215 GLint numAuxBuffers; 216 217 GLint level; 218 219 /* EXT_visual_rating / GLX 1.2 */ 220 GLint visualRating; 221 222 /* EXT_visual_info / GLX 1.2 */ 223 GLint transparentPixel; 224 /* colors are floats scaled to ints */ 225 GLint transparentRed, transparentGreen, transparentBlue, transparentAlpha; 226 GLint transparentIndex; 227 228 /* ARB_multisample / SGIS_multisample */ 229 GLint sampleBuffers; 230 GLint samples; 231 232 /* SGIX_pbuffer / GLX 1.3 */ 233 GLint maxPbufferWidth; 234 GLint maxPbufferHeight; 235 GLint maxPbufferPixels; 236 GLint optimalPbufferWidth; /* Only for SGIX_pbuffer. */ 237 GLint optimalPbufferHeight; /* Only for SGIX_pbuffer. */ 238 239 /* OML_swap_method */ 240 GLint swapMethod; 241 242 /* EXT_texture_from_pixmap */ 243 GLint bindToTextureRgb; 244 GLint bindToTextureRgba; 245 GLint bindToMipmapTexture; 246 GLint bindToTextureTargets; 247 GLint yInverted; 248 249 /* EXT_framebuffer_sRGB */ 250 GLint sRGBCapable; 251 }; 252 253 254 /** 255 * \name Bit flags used for updating material values. 256 */ 257 /*@{*/ 258 #define MAT_ATTRIB_FRONT_AMBIENT 0 259 #define MAT_ATTRIB_BACK_AMBIENT 1 260 #define MAT_ATTRIB_FRONT_DIFFUSE 2 261 #define MAT_ATTRIB_BACK_DIFFUSE 3 262 #define MAT_ATTRIB_FRONT_SPECULAR 4 263 #define MAT_ATTRIB_BACK_SPECULAR 5 264 #define MAT_ATTRIB_FRONT_EMISSION 6 265 #define MAT_ATTRIB_BACK_EMISSION 7 266 #define MAT_ATTRIB_FRONT_SHININESS 8 267 #define MAT_ATTRIB_BACK_SHININESS 9 268 #define MAT_ATTRIB_FRONT_INDEXES 10 269 #define MAT_ATTRIB_BACK_INDEXES 11 270 #define MAT_ATTRIB_MAX 12 271 272 #define MAT_ATTRIB_AMBIENT(f) (MAT_ATTRIB_FRONT_AMBIENT+(f)) 273 #define MAT_ATTRIB_DIFFUSE(f) (MAT_ATTRIB_FRONT_DIFFUSE+(f)) 274 #define MAT_ATTRIB_SPECULAR(f) (MAT_ATTRIB_FRONT_SPECULAR+(f)) 275 #define MAT_ATTRIB_EMISSION(f) (MAT_ATTRIB_FRONT_EMISSION+(f)) 276 #define MAT_ATTRIB_SHININESS(f)(MAT_ATTRIB_FRONT_SHININESS+(f)) 277 #define MAT_ATTRIB_INDEXES(f) (MAT_ATTRIB_FRONT_INDEXES+(f)) 278 279 #define MAT_INDEX_AMBIENT 0 280 #define MAT_INDEX_DIFFUSE 1 281 #define MAT_INDEX_SPECULAR 2 282 283 #define MAT_BIT_FRONT_AMBIENT (1<<MAT_ATTRIB_FRONT_AMBIENT) 284 #define MAT_BIT_BACK_AMBIENT (1<<MAT_ATTRIB_BACK_AMBIENT) 285 #define MAT_BIT_FRONT_DIFFUSE (1<<MAT_ATTRIB_FRONT_DIFFUSE) 286 #define MAT_BIT_BACK_DIFFUSE (1<<MAT_ATTRIB_BACK_DIFFUSE) 287 #define MAT_BIT_FRONT_SPECULAR (1<<MAT_ATTRIB_FRONT_SPECULAR) 288 #define MAT_BIT_BACK_SPECULAR (1<<MAT_ATTRIB_BACK_SPECULAR) 289 #define MAT_BIT_FRONT_EMISSION (1<<MAT_ATTRIB_FRONT_EMISSION) 290 #define MAT_BIT_BACK_EMISSION (1<<MAT_ATTRIB_BACK_EMISSION) 291 #define MAT_BIT_FRONT_SHININESS (1<<MAT_ATTRIB_FRONT_SHININESS) 292 #define MAT_BIT_BACK_SHININESS (1<<MAT_ATTRIB_BACK_SHININESS) 293 #define MAT_BIT_FRONT_INDEXES (1<<MAT_ATTRIB_FRONT_INDEXES) 294 #define MAT_BIT_BACK_INDEXES (1<<MAT_ATTRIB_BACK_INDEXES) 295 296 297 #define FRONT_MATERIAL_BITS (MAT_BIT_FRONT_EMISSION | \ 298 MAT_BIT_FRONT_AMBIENT | \ 299 MAT_BIT_FRONT_DIFFUSE | \ 300 MAT_BIT_FRONT_SPECULAR | \ 301 MAT_BIT_FRONT_SHININESS | \ 302 MAT_BIT_FRONT_INDEXES) 303 304 #define BACK_MATERIAL_BITS (MAT_BIT_BACK_EMISSION | \ 305 MAT_BIT_BACK_AMBIENT | \ 306 MAT_BIT_BACK_DIFFUSE | \ 307 MAT_BIT_BACK_SPECULAR | \ 308 MAT_BIT_BACK_SHININESS | \ 309 MAT_BIT_BACK_INDEXES) 310 311 #define ALL_MATERIAL_BITS (FRONT_MATERIAL_BITS | BACK_MATERIAL_BITS) 312 /*@}*/ 313 314 315 /** 316 * Material state. 317 */ 318 struct gl_material 319 { 320 GLfloat Attrib[MAT_ATTRIB_MAX][4]; 321 }; 322 323 324 /** 325 * Light state flags. 326 */ 327 /*@{*/ 328 #define LIGHT_SPOT 0x1 329 #define LIGHT_LOCAL_VIEWER 0x2 330 #define LIGHT_POSITIONAL 0x4 331 #define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER) 332 /*@}*/ 333 334 335 /** 336 * Light source state. 337 */ 338 struct gl_light 339 { 340 GLfloat Ambient[4]; /**< ambient color */ 341 GLfloat Diffuse[4]; /**< diffuse color */ 342 GLfloat Specular[4]; /**< specular color */ 343 GLfloat EyePosition[4]; /**< position in eye coordinates */ 344 GLfloat SpotDirection[4]; /**< spotlight direction in eye coordinates */ 345 GLfloat SpotExponent; 346 GLfloat SpotCutoff; /**< in degrees */ 347 GLfloat _CosCutoff; /**< = MAX(0, cos(SpotCutoff)) */ 348 GLfloat ConstantAttenuation; 349 GLfloat LinearAttenuation; 350 GLfloat QuadraticAttenuation; 351 GLboolean Enabled; /**< On/off flag */ 352 353 /** 354 * \name Derived fields 355 */ 356 /*@{*/ 357 GLbitfield _Flags; /**< Mask of LIGHT_x bits defined above */ 358 359 GLfloat _Position[4]; /**< position in eye/obj coordinates */ 360 GLfloat _VP_inf_norm[3]; /**< Norm direction to infinite light */ 361 GLfloat _h_inf_norm[3]; /**< Norm( _VP_inf_norm + <0,0,1> ) */ 362 GLfloat _NormSpotDirection[4]; /**< normalized spotlight direction */ 363 GLfloat _VP_inf_spot_attenuation; 364 365 GLfloat _MatAmbient[2][3]; /**< material ambient * light ambient */ 366 GLfloat _MatDiffuse[2][3]; /**< material diffuse * light diffuse */ 367 GLfloat _MatSpecular[2][3]; /**< material spec * light specular */ 368 /*@}*/ 369 }; 370 371 372 /** 373 * Light model state. 374 */ 375 struct gl_lightmodel 376 { 377 GLfloat Ambient[4]; /**< ambient color */ 378 GLboolean LocalViewer; /**< Local (or infinite) view point? */ 379 GLboolean TwoSide; /**< Two (or one) sided lighting? */ 380 GLenum ColorControl; /**< either GL_SINGLE_COLOR 381 * or GL_SEPARATE_SPECULAR_COLOR */ 382 }; 383 384 385 /** 386 * Accumulation buffer attribute group (GL_ACCUM_BUFFER_BIT) 387 */ 388 struct gl_accum_attrib 389 { 390 GLfloat ClearColor[4]; /**< Accumulation buffer clear color */ 391 }; 392 393 394 /** 395 * Used for storing clear color, texture border color, etc. 396 * The float values are typically unclamped. 397 */ 398 union gl_color_union 399 { 400 GLfloat f[4]; 401 GLint i[4]; 402 GLuint ui[4]; 403 }; 404 405 406 /** 407 * Color buffer attribute group (GL_COLOR_BUFFER_BIT). 408 */ 409 struct gl_colorbuffer_attrib 410 { 411 GLuint ClearIndex; /**< Index for glClear */ 412 union gl_color_union ClearColor; /**< Color for glClear, unclamped */ 413 GLuint IndexMask; /**< Color index write mask */ 414 GLubyte ColorMask[MAX_DRAW_BUFFERS][4]; /**< Each flag is 0xff or 0x0 */ 415 416 GLenum DrawBuffer[MAX_DRAW_BUFFERS]; /**< Which buffer to draw into */ 417 418 /** 419 * \name alpha testing 420 */ 421 /*@{*/ 422 GLboolean AlphaEnabled; /**< Alpha test enabled flag */ 423 GLenum AlphaFunc; /**< Alpha test function */ 424 GLfloat AlphaRefUnclamped; 425 GLclampf AlphaRef; /**< Alpha reference value */ 426 /*@}*/ 427 428 /** 429 * \name Blending 430 */ 431 /*@{*/ 432 GLbitfield BlendEnabled; /**< Per-buffer blend enable flags */ 433 434 /* NOTE: this does _not_ depend on fragment clamping or any other clamping 435 * control, only on the fixed-pointness of the render target. 436 * The query does however depend on fragment color clamping. 437 */ 438 GLfloat BlendColorUnclamped[4]; /**< Blending color */ 439 GLfloat BlendColor[4]; /**< Blending color */ 440 441 struct 442 { 443 GLenum SrcRGB; /**< RGB blend source term */ 444 GLenum DstRGB; /**< RGB blend dest term */ 445 GLenum SrcA; /**< Alpha blend source term */ 446 GLenum DstA; /**< Alpha blend dest term */ 447 GLenum EquationRGB; /**< GL_ADD, GL_SUBTRACT, etc. */ 448 GLenum EquationA; /**< GL_ADD, GL_SUBTRACT, etc. */ 449 /** 450 * Set if any blend factor uses SRC1. Computed at the time blend factors 451 * get set. 452 */ 453 GLboolean _UsesDualSrc; 454 } Blend[MAX_DRAW_BUFFERS]; 455 /** Are the blend func terms currently different for each buffer/target? */ 456 GLboolean _BlendFuncPerBuffer; 457 /** Are the blend equations currently different for each buffer/target? */ 458 GLboolean _BlendEquationPerBuffer; 459 460 /** 461 * Which advanced blending mode is in use (or BLEND_NONE). 462 * 463 * KHR_blend_equation_advanced only allows advanced blending with a single 464 * draw buffer, and NVX_blend_equation_advanced_multi_draw_buffer still 465 * requires all draw buffers to match, so we only need a single value. 466 */ 467 enum gl_advanced_blend_mode _AdvancedBlendMode; 468 469 /** Coherency requested via glEnable(GL_BLEND_ADVANCED_COHERENT_KHR)? */ 470 bool BlendCoherent; 471 /*@}*/ 472 473 /** 474 * \name Logic op 475 */ 476 /*@{*/ 477 GLboolean IndexLogicOpEnabled; /**< Color index logic op enabled flag */ 478 GLboolean ColorLogicOpEnabled; /**< RGBA logic op enabled flag */ 479 GLenum LogicOp; /**< Logic operator */ 480 481 /*@}*/ 482 483 GLboolean DitherFlag; /**< Dither enable flag */ 484 485 GLboolean _ClampFragmentColor; /** < with GL_FIXED_ONLY_ARB resolved */ 486 GLenum ClampFragmentColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */ 487 GLenum ClampReadColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */ 488 489 GLboolean sRGBEnabled; /**< Framebuffer sRGB blending/updating requested */ 490 }; 491 492 493 /** 494 * Current attribute group (GL_CURRENT_BIT). 495 */ 496 struct gl_current_attrib 497 { 498 /** 499 * \name Current vertex attributes (color, texcoords, etc). 500 * \note Values are valid only after FLUSH_VERTICES has been called. 501 * \note Index and Edgeflag current values are stored as floats in the 502 * SIX and SEVEN attribute slots. 503 * \note We need double storage for 64-bit vertex attributes 504 */ 505 GLfloat Attrib[VERT_ATTRIB_MAX][4*2]; 506 507 /** 508 * \name Current raster position attributes (always up to date after a 509 * glRasterPos call). 510 */ 511 GLfloat RasterPos[4]; 512 GLfloat RasterDistance; 513 GLfloat RasterColor[4]; 514 GLfloat RasterSecondaryColor[4]; 515 GLfloat RasterTexCoords[MAX_TEXTURE_COORD_UNITS][4]; 516 GLboolean RasterPosValid; 517 }; 518 519 520 /** 521 * Depth buffer attribute group (GL_DEPTH_BUFFER_BIT). 522 */ 523 struct gl_depthbuffer_attrib 524 { 525 GLenum Func; /**< Function for depth buffer compare */ 526 GLclampd Clear; /**< Value to clear depth buffer to */ 527 GLboolean Test; /**< Depth buffering enabled flag */ 528 GLboolean Mask; /**< Depth buffer writable? */ 529 GLboolean BoundsTest; /**< GL_EXT_depth_bounds_test */ 530 GLfloat BoundsMin, BoundsMax;/**< GL_EXT_depth_bounds_test */ 531 }; 532 533 534 /** 535 * Evaluator attribute group (GL_EVAL_BIT). 536 */ 537 struct gl_eval_attrib 538 { 539 /** 540 * \name Enable bits 541 */ 542 /*@{*/ 543 GLboolean Map1Color4; 544 GLboolean Map1Index; 545 GLboolean Map1Normal; 546 GLboolean Map1TextureCoord1; 547 GLboolean Map1TextureCoord2; 548 GLboolean Map1TextureCoord3; 549 GLboolean Map1TextureCoord4; 550 GLboolean Map1Vertex3; 551 GLboolean Map1Vertex4; 552 GLboolean Map2Color4; 553 GLboolean Map2Index; 554 GLboolean Map2Normal; 555 GLboolean Map2TextureCoord1; 556 GLboolean Map2TextureCoord2; 557 GLboolean Map2TextureCoord3; 558 GLboolean Map2TextureCoord4; 559 GLboolean Map2Vertex3; 560 GLboolean Map2Vertex4; 561 GLboolean AutoNormal; 562 /*@}*/ 563 564 /** 565 * \name Map Grid endpoints and divisions and calculated du values 566 */ 567 /*@{*/ 568 GLint MapGrid1un; 569 GLfloat MapGrid1u1, MapGrid1u2, MapGrid1du; 570 GLint MapGrid2un, MapGrid2vn; 571 GLfloat MapGrid2u1, MapGrid2u2, MapGrid2du; 572 GLfloat MapGrid2v1, MapGrid2v2, MapGrid2dv; 573 /*@}*/ 574 }; 575 576 577 /** 578 * Fog attribute group (GL_FOG_BIT). 579 */ 580 struct gl_fog_attrib 581 { 582 GLboolean Enabled; /**< Fog enabled flag */ 583 GLboolean ColorSumEnabled; 584 GLfloat ColorUnclamped[4]; /**< Fog color */ 585 GLfloat Color[4]; /**< Fog color */ 586 GLfloat Density; /**< Density >= 0.0 */ 587 GLfloat Start; /**< Start distance in eye coords */ 588 GLfloat End; /**< End distance in eye coords */ 589 GLfloat Index; /**< Fog index */ 590 GLenum Mode; /**< Fog mode */ 591 GLenum FogCoordinateSource; /**< GL_EXT_fog_coord */ 592 GLfloat _Scale; /**< (End == Start) ? 1.0 : 1.0 / (End - Start) */ 593 GLenum FogDistanceMode; /**< GL_NV_fog_distance */ 594 }; 595 596 597 /** 598 * Hint attribute group (GL_HINT_BIT). 599 * 600 * Values are always one of GL_FASTEST, GL_NICEST, or GL_DONT_CARE. 601 */ 602 struct gl_hint_attrib 603 { 604 GLenum PerspectiveCorrection; 605 GLenum PointSmooth; 606 GLenum LineSmooth; 607 GLenum PolygonSmooth; 608 GLenum Fog; 609 GLenum TextureCompression; /**< GL_ARB_texture_compression */ 610 GLenum GenerateMipmap; /**< GL_SGIS_generate_mipmap */ 611 GLenum FragmentShaderDerivative; /**< GL_ARB_fragment_shader */ 612 }; 613 614 615 /** 616 * Lighting attribute group (GL_LIGHT_BIT). 617 */ 618 struct gl_light_attrib 619 { 620 struct gl_light Light[MAX_LIGHTS]; /**< Array of light sources */ 621 struct gl_lightmodel Model; /**< Lighting model */ 622 623 /** 624 * Front and back material values. 625 * Note: must call FLUSH_VERTICES() before using. 626 */ 627 struct gl_material Material; 628 629 GLboolean Enabled; /**< Lighting enabled flag */ 630 GLboolean ColorMaterialEnabled; 631 632 GLenum ShadeModel; /**< GL_FLAT or GL_SMOOTH */ 633 GLenum ProvokingVertex; /**< GL_EXT_provoking_vertex */ 634 GLenum ColorMaterialFace; /**< GL_FRONT, BACK or FRONT_AND_BACK */ 635 GLenum ColorMaterialMode; /**< GL_AMBIENT, GL_DIFFUSE, etc */ 636 GLbitfield _ColorMaterialBitmask; /**< bitmask formed from Face and Mode */ 637 638 639 GLboolean _ClampVertexColor; 640 GLenum ClampVertexColor; /**< GL_TRUE, GL_FALSE, GL_FIXED_ONLY */ 641 642 /** 643 * Derived state for optimizations: 644 */ 645 /*@{*/ 646 GLbitfield _EnabledLights; /**< bitmask containing enabled lights */ 647 648 GLboolean _NeedEyeCoords; 649 GLboolean _NeedVertices; /**< Use fast shader? */ 650 651 GLfloat _BaseColor[2][3]; 652 /*@}*/ 653 }; 654 655 656 /** 657 * Line attribute group (GL_LINE_BIT). 658 */ 659 struct gl_line_attrib 660 { 661 GLboolean SmoothFlag; /**< GL_LINE_SMOOTH enabled? */ 662 GLboolean StippleFlag; /**< GL_LINE_STIPPLE enabled? */ 663 GLushort StipplePattern; /**< Stipple pattern */ 664 GLint StippleFactor; /**< Stipple repeat factor */ 665 GLfloat Width; /**< Line width */ 666 }; 667 668 669 /** 670 * Display list attribute group (GL_LIST_BIT). 671 */ 672 struct gl_list_attrib 673 { 674 GLuint ListBase; 675 }; 676 677 678 /** 679 * Multisample attribute group (GL_MULTISAMPLE_BIT). 680 */ 681 struct gl_multisample_attrib 682 { 683 GLboolean Enabled; 684 GLboolean SampleAlphaToCoverage; 685 GLboolean SampleAlphaToOne; 686 GLboolean SampleCoverage; 687 GLboolean SampleCoverageInvert; 688 GLboolean SampleShading; 689 690 /* ARB_texture_multisample / GL3.2 additions */ 691 GLboolean SampleMask; 692 693 GLfloat SampleCoverageValue; 694 GLfloat MinSampleShadingValue; 695 696 /** The GL spec defines this as an array but >32x MSAA is madness */ 697 GLbitfield SampleMaskValue; 698 }; 699 700 701 /** 702 * A pixelmap (see glPixelMap) 703 */ 704 struct gl_pixelmap 705 { 706 GLint Size; 707 GLfloat Map[MAX_PIXEL_MAP_TABLE]; 708 }; 709 710 711 /** 712 * Collection of all pixelmaps 713 */ 714 struct gl_pixelmaps 715 { 716 struct gl_pixelmap RtoR; /**< i.e. GL_PIXEL_MAP_R_TO_R */ 717 struct gl_pixelmap GtoG; 718 struct gl_pixelmap BtoB; 719 struct gl_pixelmap AtoA; 720 struct gl_pixelmap ItoR; 721 struct gl_pixelmap ItoG; 722 struct gl_pixelmap ItoB; 723 struct gl_pixelmap ItoA; 724 struct gl_pixelmap ItoI; 725 struct gl_pixelmap StoS; 726 }; 727 728 729 /** 730 * Pixel attribute group (GL_PIXEL_MODE_BIT). 731 */ 732 struct gl_pixel_attrib 733 { 734 GLenum ReadBuffer; /**< source buffer for glRead/CopyPixels() */ 735 736 /*--- Begin Pixel Transfer State ---*/ 737 /* Fields are in the order in which they're applied... */ 738 739 /** Scale & Bias (index shift, offset) */ 740 /*@{*/ 741 GLfloat RedBias, RedScale; 742 GLfloat GreenBias, GreenScale; 743 GLfloat BlueBias, BlueScale; 744 GLfloat AlphaBias, AlphaScale; 745 GLfloat DepthBias, DepthScale; 746 GLint IndexShift, IndexOffset; 747 /*@}*/ 748 749 /* Pixel Maps */ 750 /* Note: actual pixel maps are not part of this attrib group */ 751 GLboolean MapColorFlag; 752 GLboolean MapStencilFlag; 753 754 /*--- End Pixel Transfer State ---*/ 755 756 /** glPixelZoom */ 757 GLfloat ZoomX, ZoomY; 758 }; 759 760 761 /** 762 * Point attribute group (GL_POINT_BIT). 763 */ 764 struct gl_point_attrib 765 { 766 GLfloat Size; /**< User-specified point size */ 767 GLfloat Params[3]; /**< GL_EXT_point_parameters */ 768 GLfloat MinSize, MaxSize; /**< GL_EXT_point_parameters */ 769 GLfloat Threshold; /**< GL_EXT_point_parameters */ 770 GLboolean SmoothFlag; /**< True if GL_POINT_SMOOTH is enabled */ 771 GLboolean _Attenuated; /**< True if Params != [1, 0, 0] */ 772 GLboolean PointSprite; /**< GL_NV/ARB_point_sprite */ 773 GLbitfield CoordReplace; /**< GL_ARB_point_sprite*/ 774 GLenum SpriteRMode; /**< GL_NV_point_sprite (only!) */ 775 GLenum SpriteOrigin; /**< GL_ARB_point_sprite */ 776 }; 777 778 779 /** 780 * Polygon attribute group (GL_POLYGON_BIT). 781 */ 782 struct gl_polygon_attrib 783 { 784 GLenum FrontFace; /**< Either GL_CW or GL_CCW */ 785 GLenum FrontMode; /**< Either GL_POINT, GL_LINE or GL_FILL */ 786 GLenum BackMode; /**< Either GL_POINT, GL_LINE or GL_FILL */ 787 GLboolean _FrontBit; /**< 0=GL_CCW, 1=GL_CW */ 788 GLboolean CullFlag; /**< Culling on/off flag */ 789 GLboolean SmoothFlag; /**< True if GL_POLYGON_SMOOTH is enabled */ 790 GLboolean StippleFlag; /**< True if GL_POLYGON_STIPPLE is enabled */ 791 GLenum CullFaceMode; /**< Culling mode GL_FRONT or GL_BACK */ 792 GLfloat OffsetFactor; /**< Polygon offset factor, from user */ 793 GLfloat OffsetUnits; /**< Polygon offset units, from user */ 794 GLfloat OffsetClamp; /**< Polygon offset clamp, from user */ 795 GLboolean OffsetPoint; /**< Offset in GL_POINT mode */ 796 GLboolean OffsetLine; /**< Offset in GL_LINE mode */ 797 GLboolean OffsetFill; /**< Offset in GL_FILL mode */ 798 }; 799 800 801 /** 802 * Scissor attributes (GL_SCISSOR_BIT). 803 */ 804 struct gl_scissor_rect 805 { 806 GLint X, Y; /**< Lower left corner of box */ 807 GLsizei Width, Height; /**< Size of box */ 808 }; 809 struct gl_scissor_attrib 810 { 811 GLbitfield EnableFlags; /**< Scissor test enabled? */ 812 struct gl_scissor_rect ScissorArray[MAX_VIEWPORTS]; 813 GLint NumWindowRects; /**< Count of enabled window rectangles */ 814 GLenum WindowRectMode; /**< Whether to include or exclude the rects */ 815 struct gl_scissor_rect WindowRects[MAX_WINDOW_RECTANGLES]; 816 }; 817 818 819 /** 820 * Stencil attribute group (GL_STENCIL_BUFFER_BIT). 821 * 822 * Three sets of stencil data are tracked so that OpenGL 2.0, 823 * GL_EXT_stencil_two_side, and GL_ATI_separate_stencil can all be supported 824 * simultaneously. In each of the stencil state arrays, element 0 corresponds 825 * to GL_FRONT. Element 1 corresponds to the OpenGL 2.0 / 826 * GL_ATI_separate_stencil GL_BACK state. Element 2 corresponds to the 827 * GL_EXT_stencil_two_side GL_BACK state. 828 * 829 * The derived value \c _BackFace is either 1 or 2 depending on whether or 830 * not GL_STENCIL_TEST_TWO_SIDE_EXT is enabled. 831 * 832 * The derived value \c _TestTwoSide is set when the front-face and back-face 833 * stencil state are different. 834 */ 835 struct gl_stencil_attrib 836 { 837 GLboolean Enabled; /**< Enabled flag */ 838 GLboolean TestTwoSide; /**< GL_EXT_stencil_two_side */ 839 GLubyte ActiveFace; /**< GL_EXT_stencil_two_side (0 or 2) */ 840 GLboolean _Enabled; /**< Enabled and stencil buffer present */ 841 GLboolean _WriteEnabled; /**< _Enabled and non-zero writemasks */ 842 GLboolean _TestTwoSide; 843 GLubyte _BackFace; /**< Current back stencil state (1 or 2) */ 844 GLenum Function[3]; /**< Stencil function */ 845 GLenum FailFunc[3]; /**< Fail function */ 846 GLenum ZPassFunc[3]; /**< Depth buffer pass function */ 847 GLenum ZFailFunc[3]; /**< Depth buffer fail function */ 848 GLint Ref[3]; /**< Reference value */ 849 GLuint ValueMask[3]; /**< Value mask */ 850 GLuint WriteMask[3]; /**< Write mask */ 851 GLuint Clear; /**< Clear value */ 852 }; 853 854 855 /** 856 * An index for each type of texture object. These correspond to the GL 857 * texture target enums, such as GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP, etc. 858 * Note: the order is from highest priority to lowest priority. 859 */ 860 typedef enum 861 { 862 TEXTURE_2D_MULTISAMPLE_INDEX, 863 TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX, 864 TEXTURE_CUBE_ARRAY_INDEX, 865 TEXTURE_BUFFER_INDEX, 866 TEXTURE_2D_ARRAY_INDEX, 867 TEXTURE_1D_ARRAY_INDEX, 868 TEXTURE_EXTERNAL_INDEX, 869 TEXTURE_CUBE_INDEX, 870 TEXTURE_3D_INDEX, 871 TEXTURE_RECT_INDEX, 872 TEXTURE_2D_INDEX, 873 TEXTURE_1D_INDEX, 874 NUM_TEXTURE_TARGETS 875 } gl_texture_index; 876 877 878 /** 879 * Bit flags for each type of texture object 880 */ 881 /*@{*/ 882 #define TEXTURE_2D_MULTISAMPLE_BIT (1 << TEXTURE_2D_MULTISAMPLE_INDEX) 883 #define TEXTURE_2D_MULTISAMPLE_ARRAY_BIT (1 << TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX) 884 #define TEXTURE_CUBE_ARRAY_BIT (1 << TEXTURE_CUBE_ARRAY_INDEX) 885 #define TEXTURE_BUFFER_BIT (1 << TEXTURE_BUFFER_INDEX) 886 #define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX) 887 #define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX) 888 #define TEXTURE_EXTERNAL_BIT (1 << TEXTURE_EXTERNAL_INDEX) 889 #define TEXTURE_CUBE_BIT (1 << TEXTURE_CUBE_INDEX) 890 #define TEXTURE_3D_BIT (1 << TEXTURE_3D_INDEX) 891 #define TEXTURE_RECT_BIT (1 << TEXTURE_RECT_INDEX) 892 #define TEXTURE_2D_BIT (1 << TEXTURE_2D_INDEX) 893 #define TEXTURE_1D_BIT (1 << TEXTURE_1D_INDEX) 894 /*@}*/ 895 896 897 /** 898 * Texture image state. Drivers will typically create a subclass of this 899 * with extra fields for memory buffers, etc. 900 */ 901 struct gl_texture_image 902 { 903 GLint InternalFormat; /**< Internal format as given by the user */ 904 GLenum _BaseFormat; /**< Either GL_RGB, GL_RGBA, GL_ALPHA, 905 * GL_LUMINANCE, GL_LUMINANCE_ALPHA, 906 * GL_INTENSITY, GL_DEPTH_COMPONENT or 907 * GL_DEPTH_STENCIL_EXT only. Used for 908 * choosing TexEnv arithmetic. 909 */ 910 mesa_format TexFormat; /**< The actual texture memory format */ 911 912 GLuint Border; /**< 0 or 1 */ 913 GLuint Width; /**< = 2^WidthLog2 + 2*Border */ 914 GLuint Height; /**< = 2^HeightLog2 + 2*Border */ 915 GLuint Depth; /**< = 2^DepthLog2 + 2*Border */ 916 GLuint Width2; /**< = Width - 2*Border */ 917 GLuint Height2; /**< = Height - 2*Border */ 918 GLuint Depth2; /**< = Depth - 2*Border */ 919 GLuint WidthLog2; /**< = log2(Width2) */ 920 GLuint HeightLog2; /**< = log2(Height2) */ 921 GLuint DepthLog2; /**< = log2(Depth2) */ 922 GLuint MaxNumLevels; /**< = maximum possible number of mipmap 923 levels, computed from the dimensions */ 924 925 struct gl_texture_object *TexObject; /**< Pointer back to parent object */ 926 GLuint Level; /**< Which mipmap level am I? */ 927 /** Cube map face: index into gl_texture_object::Image[] array */ 928 GLuint Face; 929 930 /** GL_ARB_texture_multisample */ 931 GLuint NumSamples; /**< Sample count, or 0 for non-multisample */ 932 GLboolean FixedSampleLocations; /**< Same sample locations for all pixels? */ 933 }; 934 935 936 /** 937 * Indexes for cube map faces. 938 */ 939 typedef enum 940 { 941 FACE_POS_X = 0, 942 FACE_NEG_X = 1, 943 FACE_POS_Y = 2, 944 FACE_NEG_Y = 3, 945 FACE_POS_Z = 4, 946 FACE_NEG_Z = 5, 947 MAX_FACES = 6 948 } gl_face_index; 949 950 951 /** 952 * Sampler object state. These objects are new with GL_ARB_sampler_objects 953 * and OpenGL 3.3. Legacy texture objects also contain a sampler object. 954 */ 955 struct gl_sampler_object 956 { 957 mtx_t Mutex; 958 GLuint Name; 959 GLint RefCount; 960 GLchar *Label; /**< GL_KHR_debug */ 961 962 GLenum WrapS; /**< S-axis texture image wrap mode */ 963 GLenum WrapT; /**< T-axis texture image wrap mode */ 964 GLenum WrapR; /**< R-axis texture image wrap mode */ 965 GLenum MinFilter; /**< minification filter */ 966 GLenum MagFilter; /**< magnification filter */ 967 union gl_color_union BorderColor; /**< Interpreted according to texture format */ 968 GLfloat MinLod; /**< min lambda, OpenGL 1.2 */ 969 GLfloat MaxLod; /**< max lambda, OpenGL 1.2 */ 970 GLfloat LodBias; /**< OpenGL 1.4 */ 971 GLfloat MaxAnisotropy; /**< GL_EXT_texture_filter_anisotropic */ 972 GLenum CompareMode; /**< GL_ARB_shadow */ 973 GLenum CompareFunc; /**< GL_ARB_shadow */ 974 GLenum sRGBDecode; /**< GL_DECODE_EXT or GL_SKIP_DECODE_EXT */ 975 GLboolean CubeMapSeamless; /**< GL_AMD_seamless_cubemap_per_texture */ 976 }; 977 978 979 /** 980 * Texture object state. Contains the array of mipmap images, border color, 981 * wrap modes, filter modes, and shadow/texcompare state. 982 */ 983 struct gl_texture_object 984 { 985 mtx_t Mutex; /**< for thread safety */ 986 GLint RefCount; /**< reference count */ 987 GLuint Name; /**< the user-visible texture object ID */ 988 GLchar *Label; /**< GL_KHR_debug */ 989 GLenum Target; /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */ 990 gl_texture_index TargetIndex; /**< The gl_texture_unit::CurrentTex index. 991 Only valid when Target is valid. */ 992 993 struct gl_sampler_object Sampler; 994 995 GLenum DepthMode; /**< GL_ARB_depth_texture */ 996 bool StencilSampling; /**< Should we sample stencil instead of depth? */ 997 998 GLfloat Priority; /**< in [0,1] */ 999 GLint BaseLevel; /**< min mipmap level, OpenGL 1.2 */ 1000 GLint MaxLevel; /**< max mipmap level, OpenGL 1.2 */ 1001 GLint ImmutableLevels; /**< ES 3.0 / ARB_texture_view */ 1002 GLint _MaxLevel; /**< actual max mipmap level (q in the spec) */ 1003 GLfloat _MaxLambda; /**< = _MaxLevel - BaseLevel (q - p in spec) */ 1004 GLint CropRect[4]; /**< GL_OES_draw_texture */ 1005 GLenum Swizzle[4]; /**< GL_EXT_texture_swizzle */ 1006 GLuint _Swizzle; /**< same as Swizzle, but SWIZZLE_* format */ 1007 GLboolean GenerateMipmap; /**< GL_SGIS_generate_mipmap */ 1008 GLboolean _BaseComplete; /**< Is the base texture level valid? */ 1009 GLboolean _MipmapComplete; /**< Is the whole mipmap valid? */ 1010 GLboolean _IsIntegerFormat; /**< Does the texture store integer values? */ 1011 GLboolean _RenderToTexture; /**< Any rendering to this texture? */ 1012 GLboolean Purgeable; /**< Is the buffer purgeable under memory 1013 pressure? */ 1014 GLboolean Immutable; /**< GL_ARB_texture_storage */ 1015 GLboolean _IsFloat; /**< GL_OES_float_texture */ 1016 GLboolean _IsHalfFloat; /**< GL_OES_half_float_texture */ 1017 1018 GLuint MinLevel; /**< GL_ARB_texture_view */ 1019 GLuint MinLayer; /**< GL_ARB_texture_view */ 1020 GLuint NumLevels; /**< GL_ARB_texture_view */ 1021 GLuint NumLayers; /**< GL_ARB_texture_view */ 1022 1023 /** Actual texture images, indexed by [cube face] and [mipmap level] */ 1024 struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS]; 1025 1026 /** GL_ARB_texture_buffer_object */ 1027 struct gl_buffer_object *BufferObject; 1028 GLenum BufferObjectFormat; 1029 /** Equivalent Mesa format for BufferObjectFormat. */ 1030 mesa_format _BufferObjectFormat; 1031 /** GL_ARB_texture_buffer_range */ 1032 GLintptr BufferOffset; 1033 GLsizeiptr BufferSize; /**< if this is -1, use BufferObject->Size instead */ 1034 1035 /** GL_OES_EGL_image_external */ 1036 GLint RequiredTextureImageUnits; 1037 1038 /** GL_ARB_shader_image_load_store */ 1039 GLenum ImageFormatCompatibilityType; 1040 }; 1041 1042 1043 /** Up to four combiner sources are possible with GL_NV_texture_env_combine4 */ 1044 #define MAX_COMBINER_TERMS 4 1045 1046 1047 /** 1048 * Texture combine environment state. 1049 */ 1050 struct gl_tex_env_combine_state 1051 { 1052 GLenum ModeRGB; /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */ 1053 GLenum ModeA; /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */ 1054 /** Source terms: GL_PRIMARY_COLOR, GL_TEXTURE, etc */ 1055 GLenum SourceRGB[MAX_COMBINER_TERMS]; 1056 GLenum SourceA[MAX_COMBINER_TERMS]; 1057 /** Source operands: GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, etc */ 1058 GLenum OperandRGB[MAX_COMBINER_TERMS]; 1059 GLenum OperandA[MAX_COMBINER_TERMS]; 1060 GLuint ScaleShiftRGB; /**< 0, 1 or 2 */ 1061 GLuint ScaleShiftA; /**< 0, 1 or 2 */ 1062 GLuint _NumArgsRGB; /**< Number of inputs used for the RGB combiner */ 1063 GLuint _NumArgsA; /**< Number of inputs used for the A combiner */ 1064 }; 1065 1066 1067 /** 1068 * TexGenEnabled flags. 1069 */ 1070 /*@{*/ 1071 #define S_BIT 1 1072 #define T_BIT 2 1073 #define R_BIT 4 1074 #define Q_BIT 8 1075 #define STR_BITS (S_BIT | T_BIT | R_BIT) 1076 /*@}*/ 1077 1078 1079 /** 1080 * Bit flag versions of the corresponding GL_ constants. 1081 */ 1082 /*@{*/ 1083 #define TEXGEN_SPHERE_MAP 0x1 1084 #define TEXGEN_OBJ_LINEAR 0x2 1085 #define TEXGEN_EYE_LINEAR 0x4 1086 #define TEXGEN_REFLECTION_MAP_NV 0x8 1087 #define TEXGEN_NORMAL_MAP_NV 0x10 1088 1089 #define TEXGEN_NEED_NORMALS (TEXGEN_SPHERE_MAP | \ 1090 TEXGEN_REFLECTION_MAP_NV | \ 1091 TEXGEN_NORMAL_MAP_NV) 1092 #define TEXGEN_NEED_EYE_COORD (TEXGEN_SPHERE_MAP | \ 1093 TEXGEN_REFLECTION_MAP_NV | \ 1094 TEXGEN_NORMAL_MAP_NV | \ 1095 TEXGEN_EYE_LINEAR) 1096 /*@}*/ 1097 1098 1099 1100 /** Tex-gen enabled for texture unit? */ 1101 #define ENABLE_TEXGEN(unit) (1 << (unit)) 1102 1103 /** Non-identity texture matrix for texture unit? */ 1104 #define ENABLE_TEXMAT(unit) (1 << (unit)) 1105 1106 1107 /** 1108 * Texture coord generation state. 1109 */ 1110 struct gl_texgen 1111 { 1112 GLenum Mode; /**< GL_EYE_LINEAR, GL_SPHERE_MAP, etc */ 1113 GLbitfield _ModeBit; /**< TEXGEN_x bit corresponding to Mode */ 1114 GLfloat ObjectPlane[4]; 1115 GLfloat EyePlane[4]; 1116 }; 1117 1118 1119 /** 1120 * Texture unit state. Contains enable flags, texture environment/function/ 1121 * combiners, texgen state, and pointers to current texture objects. 1122 */ 1123 struct gl_texture_unit 1124 { 1125 GLbitfield Enabled; /**< bitmask of TEXTURE_*_BIT flags */ 1126 1127 GLenum EnvMode; /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */ 1128 GLclampf EnvColor[4]; 1129 GLfloat EnvColorUnclamped[4]; 1130 1131 struct gl_texgen GenS; 1132 struct gl_texgen GenT; 1133 struct gl_texgen GenR; 1134 struct gl_texgen GenQ; 1135 GLbitfield TexGenEnabled; /**< Bitwise-OR of [STRQ]_BIT values */ 1136 GLbitfield _GenFlags; /**< Bitwise-OR of Gen[STRQ]._ModeBit */ 1137 1138 GLfloat LodBias; /**< for biasing mipmap levels */ 1139 1140 /** Texture targets that have a non-default texture bound */ 1141 GLbitfield _BoundTextures; 1142 1143 /** Current sampler object (GL_ARB_sampler_objects) */ 1144 struct gl_sampler_object *Sampler; 1145 1146 /** 1147 * \name GL_EXT_texture_env_combine 1148 */ 1149 struct gl_tex_env_combine_state Combine; 1150 1151 /** 1152 * Derived state based on \c EnvMode and the \c BaseFormat of the 1153 * currently enabled texture. 1154 */ 1155 struct gl_tex_env_combine_state _EnvMode; 1156 1157 /** 1158 * Currently enabled combiner state. This will point to either 1159 * \c Combine or \c _EnvMode. 1160 */ 1161 struct gl_tex_env_combine_state *_CurrentCombine; 1162 1163 /** Current texture object pointers */ 1164 struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS]; 1165 1166 /** Points to highest priority, complete and enabled texture object */ 1167 struct gl_texture_object *_Current; 1168 1169 }; 1170 1171 1172 /** 1173 * Texture attribute group (GL_TEXTURE_BIT). 1174 */ 1175 struct gl_texture_attrib 1176 { 1177 GLuint CurrentUnit; /**< GL_ACTIVE_TEXTURE */ 1178 1179 /** GL_ARB_seamless_cubemap */ 1180 GLboolean CubeMapSeamless; 1181 1182 struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS]; 1183 1184 /** GL_ARB_texture_buffer_object */ 1185 struct gl_buffer_object *BufferObject; 1186 1187 /** Texture coord units/sets used for fragment texturing */ 1188 GLbitfield _EnabledCoordUnits; 1189 1190 /** Texture coord units that have texgen enabled */ 1191 GLbitfield _TexGenEnabled; 1192 1193 /** Texture coord units that have non-identity matrices */ 1194 GLbitfield _TexMatEnabled; 1195 1196 /** Bitwise-OR of all Texture.Unit[i]._GenFlags */ 1197 GLbitfield _GenFlags; 1198 1199 /** Largest index of a texture unit with _Current != NULL. */ 1200 GLint _MaxEnabledTexImageUnit; 1201 1202 /** Largest index + 1 of texture units that have had any CurrentTex set. */ 1203 GLint NumCurrentTexUsed; 1204 1205 struct gl_texture_unit Unit[MAX_COMBINED_TEXTURE_IMAGE_UNITS]; 1206 }; 1207 1208 1209 /** 1210 * Data structure representing a single clip plane (e.g. one of the elements 1211 * of the ctx->Transform.EyeUserPlane or ctx->Transform._ClipUserPlane array). 1212 */ 1213 typedef GLfloat gl_clip_plane[4]; 1214 1215 1216 /** 1217 * Transformation attribute group (GL_TRANSFORM_BIT). 1218 */ 1219 struct gl_transform_attrib 1220 { 1221 GLenum MatrixMode; /**< Matrix mode */ 1222 gl_clip_plane EyeUserPlane[MAX_CLIP_PLANES]; /**< User clip planes */ 1223 gl_clip_plane _ClipUserPlane[MAX_CLIP_PLANES]; /**< derived */ 1224 GLbitfield ClipPlanesEnabled; /**< on/off bitmask */ 1225 GLboolean Normalize; /**< Normalize all normals? */ 1226 GLboolean RescaleNormals; /**< GL_EXT_rescale_normal */ 1227 GLboolean RasterPositionUnclipped; /**< GL_IBM_rasterpos_clip */ 1228 GLboolean DepthClamp; /**< GL_ARB_depth_clamp */ 1229 /** GL_ARB_clip_control */ 1230 GLenum ClipOrigin; /**< GL_LOWER_LEFT or GL_UPPER_LEFT */ 1231 GLenum ClipDepthMode; /**< GL_NEGATIVE_ONE_TO_ONE or GL_ZERO_TO_ONE */ 1232 }; 1233 1234 1235 /** 1236 * Viewport attribute group (GL_VIEWPORT_BIT). 1237 */ 1238 struct gl_viewport_attrib 1239 { 1240 GLfloat X, Y; /**< position */ 1241 GLfloat Width, Height; /**< size */ 1242 GLdouble Near, Far; /**< Depth buffer range */ 1243 }; 1244 1245 1246 typedef enum { 1247 MAP_USER, 1248 MAP_INTERNAL, 1249 1250 MAP_COUNT 1251 } gl_map_buffer_index; 1252 1253 1254 /** 1255 * Fields describing a mapped buffer range. 1256 */ 1257 struct gl_buffer_mapping { 1258 GLbitfield AccessFlags; /**< Mask of GL_MAP_x_BIT flags */ 1259 GLvoid *Pointer; /**< User-space address of mapping */ 1260 GLintptr Offset; /**< Mapped offset */ 1261 GLsizeiptr Length; /**< Mapped length */ 1262 }; 1263 1264 1265 /** 1266 * Usages we've seen for a buffer object. 1267 */ 1268 typedef enum { 1269 USAGE_UNIFORM_BUFFER = 0x1, 1270 USAGE_TEXTURE_BUFFER = 0x2, 1271 USAGE_ATOMIC_COUNTER_BUFFER = 0x4, 1272 USAGE_SHADER_STORAGE_BUFFER = 0x8, 1273 USAGE_TRANSFORM_FEEDBACK_BUFFER = 0x10, 1274 USAGE_PIXEL_PACK_BUFFER = 0x20, 1275 USAGE_DISABLE_MINMAX_CACHE = 0x40, 1276 } gl_buffer_usage; 1277 1278 1279 /** 1280 * GL_ARB_vertex/pixel_buffer_object buffer object 1281 */ 1282 struct gl_buffer_object 1283 { 1284 mtx_t Mutex; 1285 GLint RefCount; 1286 GLuint Name; 1287 GLchar *Label; /**< GL_KHR_debug */ 1288 GLenum Usage; /**< GL_STREAM_DRAW_ARB, GL_STREAM_READ_ARB, etc. */ 1289 GLbitfield StorageFlags; /**< GL_MAP_PERSISTENT_BIT, etc. */ 1290 GLsizeiptrARB Size; /**< Size of buffer storage in bytes */ 1291 GLubyte *Data; /**< Location of storage either in RAM or VRAM. */ 1292 GLboolean DeletePending; /**< true if buffer object is removed from the hash */ 1293 GLboolean Written; /**< Ever written to? (for debugging) */ 1294 GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */ 1295 GLboolean Immutable; /**< GL_ARB_buffer_storage */ 1296 gl_buffer_usage UsageHistory; /**< How has this buffer been used so far? */ 1297 1298 /** Counters used for buffer usage warnings */ 1299 GLuint NumSubDataCalls; 1300 GLuint NumMapBufferWriteCalls; 1301 1302 struct gl_buffer_mapping Mappings[MAP_COUNT]; 1303 1304 /** Memoization of min/max index computations for static index buffers */ 1305 struct hash_table *MinMaxCache; 1306 unsigned MinMaxCacheHitIndices; 1307 unsigned MinMaxCacheMissIndices; 1308 bool MinMaxCacheDirty; 1309 }; 1310 1311 1312 /** 1313 * Client pixel packing/unpacking attributes 1314 */ 1315 struct gl_pixelstore_attrib 1316 { 1317 GLint Alignment; 1318 GLint RowLength; 1319 GLint SkipPixels; 1320 GLint SkipRows; 1321 GLint ImageHeight; 1322 GLint SkipImages; 1323 GLboolean SwapBytes; 1324 GLboolean LsbFirst; 1325 GLboolean Invert; /**< GL_MESA_pack_invert */ 1326 GLint CompressedBlockWidth; /**< GL_ARB_compressed_texture_pixel_storage */ 1327 GLint CompressedBlockHeight; 1328 GLint CompressedBlockDepth; 1329 GLint CompressedBlockSize; 1330 struct gl_buffer_object *BufferObj; /**< GL_ARB_pixel_buffer_object */ 1331 }; 1332 1333 1334 /** 1335 * Vertex array information which is derived from gl_array_attributes 1336 * and gl_vertex_buffer_binding information. Used by the VBO module and 1337 * device drivers. 1338 */ 1339 struct gl_vertex_array 1340 { 1341 GLint Size; /**< components per element (1,2,3,4) */ 1342 GLenum Type; /**< datatype: GL_FLOAT, GL_INT, etc */ 1343 GLenum Format; /**< default: GL_RGBA, but may be GL_BGRA */ 1344 GLsizei StrideB; /**< actual stride in bytes */ 1345 GLuint _ElementSize; /**< size of each element in bytes */ 1346 const GLubyte *Ptr; /**< Points to array data */ 1347 GLboolean Normalized; /**< GL_ARB_vertex_program */ 1348 GLboolean Integer; /**< Integer-valued? */ 1349 GLboolean Doubles; /**< double precision values are not converted to floats */ 1350 GLuint InstanceDivisor; /**< GL_ARB_instanced_arrays */ 1351 1352 struct gl_buffer_object *BufferObj;/**< GL_ARB_vertex_buffer_object */ 1353 }; 1354 1355 1356 /** 1357 * Attributes to describe a vertex array. 1358 * 1359 * Contains the size, type, format and normalization flag, 1360 * along with the index of a vertex buffer binding point. 1361 * 1362 * Note that the Stride field corresponds to VERTEX_ATTRIB_ARRAY_STRIDE 1363 * and is only present for backwards compatibility reasons. 1364 * Rendering always uses VERTEX_BINDING_STRIDE. 1365 * The gl*Pointer() functions will set VERTEX_ATTRIB_ARRAY_STRIDE 1366 * and VERTEX_BINDING_STRIDE to the same value, while 1367 * glBindVertexBuffer() will only set VERTEX_BINDING_STRIDE. 1368 */ 1369 struct gl_array_attributes 1370 { 1371 GLint Size; /**< Components per element (1,2,3,4) */ 1372 GLenum Type; /**< Datatype: GL_FLOAT, GL_INT, etc */ 1373 GLenum Format; /**< Default: GL_RGBA, but may be GL_BGRA */ 1374 GLsizei Stride; /**< Stride as specified with gl*Pointer() */ 1375 const GLubyte *Ptr; /**< Points to client array data. Not used when a VBO is bound */ 1376 GLintptr RelativeOffset; /**< Offset of the first element relative to the binding offset */ 1377 GLboolean Enabled; /**< Whether the array is enabled */ 1378 GLboolean Normalized; /**< Fixed-point values are normalized when converted to floats */ 1379 GLboolean Integer; /**< Fixed-point values are not converted to floats */ 1380 GLboolean Doubles; /**< double precision values are not converted to floats */ 1381 GLuint _ElementSize; /**< Size of each element in bytes */ 1382 GLuint BufferBindingIndex; /**< Vertex buffer binding */ 1383 }; 1384 1385 1386 /** 1387 * This describes the buffer object used for a vertex array (or 1388 * multiple vertex arrays). If BufferObj points to the default/null 1389 * buffer object, then the vertex array lives in user memory and not a VBO. 1390 */ 1391 struct gl_vertex_buffer_binding 1392 { 1393 GLintptr Offset; /**< User-specified offset */ 1394 GLsizei Stride; /**< User-specified stride */ 1395 GLuint InstanceDivisor; /**< GL_ARB_instanced_arrays */ 1396 struct gl_buffer_object *BufferObj; /**< GL_ARB_vertex_buffer_object */ 1397 GLbitfield64 _BoundArrays; /**< Arrays bound to this binding point */ 1398 }; 1399 1400 1401 /** 1402 * A representation of "Vertex Array Objects" (VAOs) from OpenGL 3.1+, 1403 * GL_ARB_vertex_array_object, or the original GL_APPLE_vertex_array_object 1404 * extension. 1405 */ 1406 struct gl_vertex_array_object 1407 { 1408 /** Name of the VAO as received from glGenVertexArray. */ 1409 GLuint Name; 1410 1411 GLint RefCount; 1412 1413 GLchar *Label; /**< GL_KHR_debug */ 1414 1415 mtx_t Mutex; 1416 1417 /** 1418 * Does the VAO use ARB semantics or Apple semantics? 1419 * 1420 * There are several ways in which ARB_vertex_array_object and 1421 * APPLE_vertex_array_object VAOs have differing semantics. At the very 1422 * least, 1423 * 1424 * - ARB VAOs require that all array data be sourced from vertex buffer 1425 * objects, but Apple VAOs do not. 1426 * 1427 * - ARB VAOs require that names come from GenVertexArrays. 1428 * 1429 * This flag notes which behavior governs this VAO. 1430 */ 1431 GLboolean ARBsemantics; 1432 1433 /** 1434 * Has this array object been bound? 1435 */ 1436 GLboolean EverBound; 1437 1438 /** 1439 * Derived vertex attribute arrays 1440 * 1441 * This is a legacy data structure created from gl_vertex_attrib_array and 1442 * gl_vertex_buffer_binding, for compatibility with existing driver code. 1443 */ 1444 struct gl_vertex_array _VertexAttrib[VERT_ATTRIB_MAX]; 1445 1446 /** Vertex attribute arrays */ 1447 struct gl_array_attributes VertexAttrib[VERT_ATTRIB_MAX]; 1448 1449 /** Vertex buffer bindings */ 1450 struct gl_vertex_buffer_binding BufferBinding[VERT_ATTRIB_MAX]; 1451 1452 /** Mask indicating which vertex arrays have vertex buffer associated. */ 1453 GLbitfield64 VertexAttribBufferMask; 1454 1455 /** Mask of VERT_BIT_* values indicating which arrays are enabled */ 1456 GLbitfield64 _Enabled; 1457 1458 /** Mask of VERT_BIT_* values indicating changed/dirty arrays */ 1459 GLbitfield64 NewArrays; 1460 1461 /** The index buffer (also known as the element array buffer in OpenGL). */ 1462 struct gl_buffer_object *IndexBufferObj; 1463 }; 1464 1465 1466 /** Used to signal when transitioning from one kind of drawing method 1467 * to another. 1468 */ 1469 typedef enum { 1470 DRAW_NONE, /**< Initial value only */ 1471 DRAW_BEGIN_END, 1472 DRAW_DISPLAY_LIST, 1473 DRAW_ARRAYS 1474 } gl_draw_method; 1475 1476 /** 1477 * Enum for the OpenGL APIs we know about and may support. 1478 * 1479 * NOTE: This must match the api_enum table in 1480 * src/mesa/main/get_hash_generator.py 1481 */ 1482 typedef enum 1483 { 1484 API_OPENGL_COMPAT, /* legacy / compatibility contexts */ 1485 API_OPENGLES, 1486 API_OPENGLES2, 1487 API_OPENGL_CORE, 1488 API_OPENGL_LAST = API_OPENGL_CORE 1489 } gl_api; 1490 1491 /** 1492 * Vertex array state 1493 */ 1494 struct gl_array_attrib 1495 { 1496 /** Currently bound array object. See _mesa_BindVertexArrayAPPLE() */ 1497 struct gl_vertex_array_object *VAO; 1498 1499 /** The default vertex array object */ 1500 struct gl_vertex_array_object *DefaultVAO; 1501 1502 /** The last VAO accessed by a DSA function */ 1503 struct gl_vertex_array_object *LastLookedUpVAO; 1504 1505 /** Array objects (GL_ARB/APPLE_vertex_array_object) */ 1506 struct _mesa_HashTable *Objects; 1507 1508 GLint ActiveTexture; /**< Client Active Texture */ 1509 GLuint LockFirst; /**< GL_EXT_compiled_vertex_array */ 1510 GLuint LockCount; /**< GL_EXT_compiled_vertex_array */ 1511 1512 /** 1513 * \name Primitive restart controls 1514 * 1515 * Primitive restart is enabled if either \c PrimitiveRestart or 1516 * \c PrimitiveRestartFixedIndex is set. 1517 */ 1518 /*@{*/ 1519 GLboolean PrimitiveRestart; 1520 GLboolean PrimitiveRestartFixedIndex; 1521 GLboolean _PrimitiveRestart; 1522 GLuint RestartIndex; 1523 /*@}*/ 1524 1525 /** One of the DRAW_xxx flags, not consumed by drivers */ 1526 gl_draw_method DrawMethod; 1527 1528 /* GL_ARB_vertex_buffer_object */ 1529 struct gl_buffer_object *ArrayBufferObj; 1530 1531 /** 1532 * Vertex arrays as consumed by a driver. 1533 * The array pointer is set up only by the VBO module. 1534 */ 1535 const struct gl_vertex_array **_DrawArrays; /**< 0..VERT_ATTRIB_MAX-1 */ 1536 1537 /** Legal array datatypes and the API for which they have been computed */ 1538 GLbitfield LegalTypesMask; 1539 gl_api LegalTypesMaskAPI; 1540 }; 1541 1542 1543 /** 1544 * Feedback buffer state 1545 */ 1546 struct gl_feedback 1547 { 1548 GLenum Type; 1549 GLbitfield _Mask; /**< FB_* bits */ 1550 GLfloat *Buffer; 1551 GLuint BufferSize; 1552 GLuint Count; 1553 }; 1554 1555 1556 /** 1557 * Selection buffer state 1558 */ 1559 struct gl_selection 1560 { 1561 GLuint *Buffer; /**< selection buffer */ 1562 GLuint BufferSize; /**< size of the selection buffer */ 1563 GLuint BufferCount; /**< number of values in the selection buffer */ 1564 GLuint Hits; /**< number of records in the selection buffer */ 1565 GLuint NameStackDepth; /**< name stack depth */ 1566 GLuint NameStack[MAX_NAME_STACK_DEPTH]; /**< name stack */ 1567 GLboolean HitFlag; /**< hit flag */ 1568 GLfloat HitMinZ; /**< minimum hit depth */ 1569 GLfloat HitMaxZ; /**< maximum hit depth */ 1570 }; 1571 1572 1573 /** 1574 * 1-D Evaluator control points 1575 */ 1576 struct gl_1d_map 1577 { 1578 GLuint Order; /**< Number of control points */ 1579 GLfloat u1, u2, du; /**< u1, u2, 1.0/(u2-u1) */ 1580 GLfloat *Points; /**< Points to contiguous control points */ 1581 }; 1582 1583 1584 /** 1585 * 2-D Evaluator control points 1586 */ 1587 struct gl_2d_map 1588 { 1589 GLuint Uorder; /**< Number of control points in U dimension */ 1590 GLuint Vorder; /**< Number of control points in V dimension */ 1591 GLfloat u1, u2, du; 1592 GLfloat v1, v2, dv; 1593 GLfloat *Points; /**< Points to contiguous control points */ 1594 }; 1595 1596 1597 /** 1598 * All evaluator control point state 1599 */ 1600 struct gl_evaluators 1601 { 1602 /** 1603 * \name 1-D maps 1604 */ 1605 /*@{*/ 1606 struct gl_1d_map Map1Vertex3; 1607 struct gl_1d_map Map1Vertex4; 1608 struct gl_1d_map Map1Index; 1609 struct gl_1d_map Map1Color4; 1610 struct gl_1d_map Map1Normal; 1611 struct gl_1d_map Map1Texture1; 1612 struct gl_1d_map Map1Texture2; 1613 struct gl_1d_map Map1Texture3; 1614 struct gl_1d_map Map1Texture4; 1615 /*@}*/ 1616 1617 /** 1618 * \name 2-D maps 1619 */ 1620 /*@{*/ 1621 struct gl_2d_map Map2Vertex3; 1622 struct gl_2d_map Map2Vertex4; 1623 struct gl_2d_map Map2Index; 1624 struct gl_2d_map Map2Color4; 1625 struct gl_2d_map Map2Normal; 1626 struct gl_2d_map Map2Texture1; 1627 struct gl_2d_map Map2Texture2; 1628 struct gl_2d_map Map2Texture3; 1629 struct gl_2d_map Map2Texture4; 1630 /*@}*/ 1631 }; 1632 1633 1634 struct gl_transform_feedback_varying_info 1635 { 1636 char *Name; 1637 GLenum Type; 1638 GLint BufferIndex; 1639 GLint Size; 1640 GLint Offset; 1641 }; 1642 1643 1644 /** 1645 * Per-output info vertex shaders for transform feedback. 1646 */ 1647 struct gl_transform_feedback_output 1648 { 1649 uint32_t OutputRegister; 1650 uint32_t OutputBuffer; 1651 uint32_t NumComponents; 1652 uint32_t StreamId; 1653 1654 /** offset (in DWORDs) of this output within the interleaved structure */ 1655 uint32_t DstOffset; 1656 1657 /** 1658 * Offset into the output register of the data to output. For example, 1659 * if NumComponents is 2 and ComponentOffset is 1, then the data to 1660 * offset is in the y and z components of the output register. 1661 */ 1662 uint32_t ComponentOffset; 1663 }; 1664 1665 1666 struct gl_transform_feedback_buffer 1667 { 1668 uint32_t Binding; 1669 1670 uint32_t NumVaryings; 1671 1672 /** 1673 * Total number of components stored in each buffer. This may be used by 1674 * hardware back-ends to determine the correct stride when interleaving 1675 * multiple transform feedback outputs in the same buffer. 1676 */ 1677 uint32_t Stride; 1678 1679 /** 1680 * Which transform feedback stream this buffer binding is associated with. 1681 */ 1682 uint32_t Stream; 1683 }; 1684 1685 1686 /** Post-link transform feedback info. */ 1687 struct gl_transform_feedback_info 1688 { 1689 unsigned NumOutputs; 1690 1691 /* Bitmask of active buffer indices. */ 1692 unsigned ActiveBuffers; 1693 1694 struct gl_transform_feedback_output *Outputs; 1695 1696 /** Transform feedback varyings used for the linking of this shader program. 1697 * 1698 * Use for glGetTransformFeedbackVarying(). 1699 */ 1700 struct gl_transform_feedback_varying_info *Varyings; 1701 GLint NumVarying; 1702 1703 struct gl_transform_feedback_buffer Buffers[MAX_FEEDBACK_BUFFERS]; 1704 }; 1705 1706 1707 /** 1708 * Transform feedback object state 1709 */ 1710 struct gl_transform_feedback_object 1711 { 1712 GLuint Name; /**< AKA the object ID */ 1713 GLint RefCount; 1714 GLchar *Label; /**< GL_KHR_debug */ 1715 GLboolean Active; /**< Is transform feedback enabled? */ 1716 GLboolean Paused; /**< Is transform feedback paused? */ 1717 GLboolean EndedAnytime; /**< Has EndTransformFeedback been called 1718 at least once? */ 1719 GLboolean EverBound; /**< Has this object been bound? */ 1720 1721 /** 1722 * GLES: if Active is true, remaining number of primitives which can be 1723 * rendered without overflow. This is necessary to track because GLES 1724 * requires us to generate INVALID_OPERATION if a call to glDrawArrays or 1725 * glDrawArraysInstanced would overflow transform feedback buffers. 1726 * Undefined if Active is false. 1727 * 1728 * Not tracked for desktop GL since it's unnecessary. 1729 */ 1730 unsigned GlesRemainingPrims; 1731 1732 /** 1733 * The program active when BeginTransformFeedback() was called. 1734 * When active and unpaused, this equals ctx->Shader.CurrentProgram[stage], 1735 * where stage is the pipeline stage that is the source of data for 1736 * transform feedback. 1737 */ 1738 struct gl_program *program; 1739 1740 /** The feedback buffers */ 1741 GLuint BufferNames[MAX_FEEDBACK_BUFFERS]; 1742 struct gl_buffer_object *Buffers[MAX_FEEDBACK_BUFFERS]; 1743 1744 /** Start of feedback data in dest buffer */ 1745 GLintptr Offset[MAX_FEEDBACK_BUFFERS]; 1746 1747 /** 1748 * Max data to put into dest buffer (in bytes). Computed based on 1749 * RequestedSize and the actual size of the buffer. 1750 */ 1751 GLsizeiptr Size[MAX_FEEDBACK_BUFFERS]; 1752 1753 /** 1754 * Size that was specified when the buffer was bound. If the buffer was 1755 * bound with glBindBufferBase() or glBindBufferOffsetEXT(), this value is 1756 * zero. 1757 */ 1758 GLsizeiptr RequestedSize[MAX_FEEDBACK_BUFFERS]; 1759 }; 1760 1761 1762 /** 1763 * Context state for transform feedback. 1764 */ 1765 struct gl_transform_feedback_state 1766 { 1767 GLenum Mode; /**< GL_POINTS, GL_LINES or GL_TRIANGLES */ 1768 1769 /** The general binding point (GL_TRANSFORM_FEEDBACK_BUFFER) */ 1770 struct gl_buffer_object *CurrentBuffer; 1771 1772 /** The table of all transform feedback objects */ 1773 struct _mesa_HashTable *Objects; 1774 1775 /** The current xform-fb object (GL_TRANSFORM_FEEDBACK_BINDING) */ 1776 struct gl_transform_feedback_object *CurrentObject; 1777 1778 /** The default xform-fb object (Name==0) */ 1779 struct gl_transform_feedback_object *DefaultObject; 1780 }; 1781 1782 1783 /** 1784 * A "performance monitor" as described in AMD_performance_monitor. 1785 */ 1786 struct gl_perf_monitor_object 1787 { 1788 GLuint Name; 1789 1790 /** True if the monitor is currently active (Begin called but not End). */ 1791 GLboolean Active; 1792 1793 /** 1794 * True if the monitor has ended. 1795 * 1796 * This is distinct from !Active because it may never have began. 1797 */ 1798 GLboolean Ended; 1799 1800 /** 1801 * A list of groups with currently active counters. 1802 * 1803 * ActiveGroups[g] == n if there are n counters active from group 'g'. 1804 */ 1805 unsigned *ActiveGroups; 1806 1807 /** 1808 * An array of bitsets, subscripted by group ID, then indexed by counter ID. 1809 * 1810 * Checking whether counter 'c' in group 'g' is active can be done via: 1811 * 1812 * BITSET_TEST(ActiveCounters[g], c) 1813 */ 1814 GLuint **ActiveCounters; 1815 }; 1816 1817 1818 union gl_perf_monitor_counter_value 1819 { 1820 float f; 1821 uint64_t u64; 1822 uint32_t u32; 1823 }; 1824 1825 1826 struct gl_perf_monitor_counter 1827 { 1828 /** Human readable name for the counter. */ 1829 const char *Name; 1830 1831 /** 1832 * Data type of the counter. Valid values are FLOAT, UNSIGNED_INT, 1833 * UNSIGNED_INT64_AMD, and PERCENTAGE_AMD. 1834 */ 1835 GLenum Type; 1836 1837 /** Minimum counter value. */ 1838 union gl_perf_monitor_counter_value Minimum; 1839 1840 /** Maximum counter value. */ 1841 union gl_perf_monitor_counter_value Maximum; 1842 }; 1843 1844 1845 struct gl_perf_monitor_group 1846 { 1847 /** Human readable name for the group. */ 1848 const char *Name; 1849 1850 /** 1851 * Maximum number of counters in this group which can be active at the 1852 * same time. 1853 */ 1854 GLuint MaxActiveCounters; 1855 1856 /** Array of counters within this group. */ 1857 const struct gl_perf_monitor_counter *Counters; 1858 GLuint NumCounters; 1859 }; 1860 1861 1862 /** 1863 * Context state for AMD_performance_monitor. 1864 */ 1865 struct gl_perf_monitor_state 1866 { 1867 /** Array of performance monitor groups (indexed by group ID) */ 1868 const struct gl_perf_monitor_group *Groups; 1869 GLuint NumGroups; 1870 1871 /** The table of all performance monitors. */ 1872 struct _mesa_HashTable *Monitors; 1873 }; 1874 1875 1876 /** 1877 * Names of the various vertex/fragment program register files, etc. 1878 * 1879 * NOTE: first four tokens must fit into 2 bits (see t_vb_arbprogram.c) 1880 * All values should fit in a 4-bit field. 1881 * 1882 * NOTE: PROGRAM_STATE_VAR, PROGRAM_CONSTANT, and PROGRAM_UNIFORM can all be 1883 * considered to be "uniform" variables since they can only be set outside 1884 * glBegin/End. They're also all stored in the same Parameters array. 1885 */ 1886 typedef enum 1887 { 1888 PROGRAM_TEMPORARY, /**< machine->Temporary[] */ 1889 PROGRAM_ARRAY, /**< Arrays & Matrixes */ 1890 PROGRAM_INPUT, /**< machine->Inputs[] */ 1891 PROGRAM_OUTPUT, /**< machine->Outputs[] */ 1892 PROGRAM_STATE_VAR, /**< gl_program->Parameters[] */ 1893 PROGRAM_CONSTANT, /**< gl_program->Parameters[] */ 1894 PROGRAM_UNIFORM, /**< gl_program->Parameters[] */ 1895 PROGRAM_WRITE_ONLY, /**< A dummy, write-only register */ 1896 PROGRAM_ADDRESS, /**< machine->AddressReg */ 1897 PROGRAM_SAMPLER, /**< for shader samplers, compile-time only */ 1898 PROGRAM_SYSTEM_VALUE,/**< InstanceId, PrimitiveID, etc. */ 1899 PROGRAM_UNDEFINED, /**< Invalid/TBD value */ 1900 PROGRAM_IMMEDIATE, /**< Immediate value, used by TGSI */ 1901 PROGRAM_BUFFER, /**< for shader buffers, compile-time only */ 1902 PROGRAM_MEMORY, /**< for shared, global and local memory */ 1903 PROGRAM_IMAGE, /**< for shader images, compile-time only */ 1904 PROGRAM_FILE_MAX 1905 } gl_register_file; 1906 1907 1908 /** 1909 * Base class for any kind of program object 1910 */ 1911 struct gl_program 1912 { 1913 /** FIXME: This must be first until we split shader_info from nir_shader */ 1914 struct shader_info info; 1915 1916 mtx_t Mutex; 1917 GLuint Id; 1918 GLint RefCount; 1919 GLubyte *String; /**< Null-terminated program text */ 1920 1921 GLenum Target; /**< GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_GEOMETRY_PROGRAM_NV */ 1922 GLenum Format; /**< String encoding format */ 1923 1924 GLboolean _Used; /**< Ever used for drawing? Used for debugging */ 1925 1926 struct nir_shader *nir; 1927 1928 bool is_arb_asm; /** Is this an ARB assembly-style program */ 1929 1930 GLbitfield64 SecondaryOutputsWritten; /**< Subset of OutputsWritten outputs written with non-zero index. */ 1931 GLbitfield TexturesUsed[MAX_COMBINED_TEXTURE_IMAGE_UNITS]; /**< TEXTURE_x_BIT bitmask */ 1932 GLbitfield SamplersUsed; /**< Bitfield of which samplers are used */ 1933 GLbitfield ShadowSamplers; /**< Texture units used for shadow sampling. */ 1934 GLbitfield ExternalSamplersUsed; /**< Texture units used for samplerExternalOES */ 1935 1936 /* Vertex and geometry shaders fields */ 1937 unsigned ClipDistanceArraySize; 1938 unsigned CullDistanceArraySize; 1939 1940 /* Fragement shader only fields */ 1941 GLboolean OriginUpperLeft; 1942 GLboolean PixelCenterInteger; 1943 1944 /** Named parameters, constants, etc. from program text */ 1945 struct gl_program_parameter_list *Parameters; 1946 1947 /** Map from sampler unit to texture unit (set by glUniform1i()) */ 1948 GLubyte SamplerUnits[MAX_SAMPLERS]; 1949 1950 /* FIXME: We should be able to make this struct a union. However some 1951 * drivers (i915/fragment_programs, swrast/prog_execute) mix the use of 1952 * these fields, we should fix this. 1953 */ 1954 struct { 1955 /** Fields used by GLSL programs */ 1956 struct { 1957 /** Data shared by gl_program and gl_shader_program */ 1958 struct gl_shader_program_data *data; 1959 1960 struct gl_active_atomic_buffer **AtomicBuffers; 1961 1962 /** Post-link transform feedback info. */ 1963 struct gl_transform_feedback_info *LinkedTransformFeedback; 1964 1965 /** 1966 * Number of types for subroutine uniforms. 1967 */ 1968 GLuint NumSubroutineUniformTypes; 1969 1970 /** 1971 * Subroutine uniform remap table 1972 * based on the program level uniform remap table. 1973 */ 1974 GLuint NumSubroutineUniforms; /* non-sparse total */ 1975 GLuint NumSubroutineUniformRemapTable; 1976 struct gl_uniform_storage **SubroutineUniformRemapTable; 1977 1978 /** 1979 * Num of subroutine functions for this stage and storage for them. 1980 */ 1981 GLuint NumSubroutineFunctions; 1982 GLuint MaxSubroutineFunctionIndex; 1983 struct gl_subroutine_function *SubroutineFunctions; 1984 1985 /** 1986 * Map from image uniform index to image unit (set by glUniform1i()) 1987 * 1988 * An image uniform index is associated with each image uniform by 1989 * the linker. The image index associated with each uniform is 1990 * stored in the \c gl_uniform_storage::image field. 1991 */ 1992 GLubyte ImageUnits[MAX_IMAGE_UNIFORMS]; 1993 1994 /** 1995 * Access qualifier specified in the shader for each image uniform 1996 * index. Either \c GL_READ_ONLY, \c GL_WRITE_ONLY or \c 1997 * GL_READ_WRITE. 1998 * 1999 * It may be different, though only more strict than the value of 2000 * \c gl_image_unit::Access for the corresponding image unit. 2001 */ 2002 GLenum ImageAccess[MAX_IMAGE_UNIFORMS]; 2003 2004 struct gl_uniform_block **UniformBlocks; 2005 struct gl_uniform_block **ShaderStorageBlocks; 2006 2007 /** Which texture target is being sampled 2008 * (TEXTURE_1D/2D/3D/etc_INDEX) 2009 */ 2010 gl_texture_index SamplerTargets[MAX_SAMPLERS]; 2011 2012 union { 2013 struct { 2014 /** 2015 * A bitmask of gl_advanced_blend_mode values 2016 */ 2017 GLbitfield BlendSupport; 2018 } fs; 2019 }; 2020 } sh; 2021 2022 /** ARB assembly-style program fields */ 2023 struct { 2024 struct prog_instruction *Instructions; 2025 2026 /** 2027 * Local parameters used by the program. 2028 * 2029 * It's dynamically allocated because it is rarely used (just 2030 * assembly-style programs), and MAX_PROGRAM_LOCAL_PARAMS entries 2031 * once it's allocated. 2032 */ 2033 GLfloat (*LocalParams)[4]; 2034 2035 /** Bitmask of which register files are read/written with indirect 2036 * addressing. Mask of (1 << PROGRAM_x) bits. 2037 */ 2038 GLbitfield IndirectRegisterFiles; 2039 2040 /** Logical counts */ 2041 /*@{*/ 2042 GLuint NumInstructions; 2043 GLuint NumTemporaries; 2044 GLuint NumParameters; 2045 GLuint NumAttributes; 2046 GLuint NumAddressRegs; 2047 GLuint NumAluInstructions; 2048 GLuint NumTexInstructions; 2049 GLuint NumTexIndirections; 2050 /*@}*/ 2051 /** Native, actual h/w counts */ 2052 /*@{*/ 2053 GLuint NumNativeInstructions; 2054 GLuint NumNativeTemporaries; 2055 GLuint NumNativeParameters; 2056 GLuint NumNativeAttributes; 2057 GLuint NumNativeAddressRegs; 2058 GLuint NumNativeAluInstructions; 2059 GLuint NumNativeTexInstructions; 2060 GLuint NumNativeTexIndirections; 2061 /*@}*/ 2062 2063 /** Used by ARB assembly-style programs. Can only be true for vertex 2064 * programs. 2065 */ 2066 GLboolean IsPositionInvariant; 2067 } arb; 2068 }; 2069 }; 2070 2071 2072 /** 2073 * State common to vertex and fragment programs. 2074 */ 2075 struct gl_program_state 2076 { 2077 GLint ErrorPos; /* GL_PROGRAM_ERROR_POSITION_ARB/NV */ 2078 const char *ErrorString; /* GL_PROGRAM_ERROR_STRING_ARB/NV */ 2079 }; 2080 2081 2082 /** 2083 * Context state for vertex programs. 2084 */ 2085 struct gl_vertex_program_state 2086 { 2087 GLboolean Enabled; /**< User-set GL_VERTEX_PROGRAM_ARB/NV flag */ 2088 GLboolean _Enabled; /**< Enabled and _valid_ user program? */ 2089 GLboolean PointSizeEnabled; /**< GL_VERTEX_PROGRAM_POINT_SIZE_ARB/NV */ 2090 GLboolean TwoSideEnabled; /**< GL_VERTEX_PROGRAM_TWO_SIDE_ARB/NV */ 2091 /** Computed two sided lighting for fixed function/programs. */ 2092 GLboolean _TwoSideEnabled; 2093 struct gl_program *Current; /**< User-bound vertex program */ 2094 2095 /** Currently enabled and valid vertex program (including internal 2096 * programs, user-defined vertex programs and GLSL vertex shaders). 2097 * This is the program we must use when rendering. 2098 */ 2099 struct gl_program *_Current; 2100 2101 GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */ 2102 2103 /** Should fixed-function T&L be implemented with a vertex prog? */ 2104 GLboolean _MaintainTnlProgram; 2105 2106 /** Program to emulate fixed-function T&L (see above) */ 2107 struct gl_program *_TnlProgram; 2108 2109 /** Cache of fixed-function programs */ 2110 struct gl_program_cache *Cache; 2111 2112 GLboolean _Overriden; 2113 }; 2114 2115 /** 2116 * Context state for tessellation control programs. 2117 */ 2118 struct gl_tess_ctrl_program_state 2119 { 2120 /** Currently bound and valid shader. */ 2121 struct gl_program *_Current; 2122 2123 GLint patch_vertices; 2124 GLfloat patch_default_outer_level[4]; 2125 GLfloat patch_default_inner_level[2]; 2126 }; 2127 2128 /** 2129 * Context state for tessellation evaluation programs. 2130 */ 2131 struct gl_tess_eval_program_state 2132 { 2133 /** Currently bound and valid shader. */ 2134 struct gl_program *_Current; 2135 }; 2136 2137 /** 2138 * Context state for geometry programs. 2139 */ 2140 struct gl_geometry_program_state 2141 { 2142 /** Currently enabled and valid program (including internal programs 2143 * and compiled shader programs). 2144 */ 2145 struct gl_program *_Current; 2146 }; 2147 2148 /** 2149 * Context state for fragment programs. 2150 */ 2151 struct gl_fragment_program_state 2152 { 2153 GLboolean Enabled; /**< User-set fragment program enable flag */ 2154 GLboolean _Enabled; /**< Enabled and _valid_ user program? */ 2155 struct gl_program *Current; /**< User-bound fragment program */ 2156 2157 /** Currently enabled and valid fragment program (including internal 2158 * programs, user-defined fragment programs and GLSL fragment shaders). 2159 * This is the program we must use when rendering. 2160 */ 2161 struct gl_program *_Current; 2162 2163 GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */ 2164 2165 /** Should fixed-function texturing be implemented with a fragment prog? */ 2166 GLboolean _MaintainTexEnvProgram; 2167 2168 /** Program to emulate fixed-function texture env/combine (see above) */ 2169 struct gl_program *_TexEnvProgram; 2170 2171 /** Cache of fixed-function programs */ 2172 struct gl_program_cache *Cache; 2173 }; 2174 2175 2176 /** 2177 * Context state for compute programs. 2178 */ 2179 struct gl_compute_program_state 2180 { 2181 /** Currently enabled and valid program (including internal programs 2182 * and compiled shader programs). 2183 */ 2184 struct gl_program *_Current; 2185 }; 2186 2187 2188 /** 2189 * ATI_fragment_shader runtime state 2190 */ 2191 2192 struct atifs_instruction; 2193 struct atifs_setupinst; 2194 2195 /** 2196 * ATI fragment shader 2197 */ 2198 struct ati_fragment_shader 2199 { 2200 GLuint Id; 2201 GLint RefCount; 2202 struct atifs_instruction *Instructions[2]; 2203 struct atifs_setupinst *SetupInst[2]; 2204 GLfloat Constants[8][4]; 2205 GLbitfield LocalConstDef; /**< Indicates which constants have been set */ 2206 GLubyte numArithInstr[2]; 2207 GLubyte regsAssigned[2]; 2208 GLubyte NumPasses; /**< 1 or 2 */ 2209 GLubyte cur_pass; 2210 GLubyte last_optype; 2211 GLboolean interpinp1; 2212 GLboolean isValid; 2213 GLuint swizzlerq; 2214 struct gl_program *Program; 2215 }; 2216 2217 /** 2218 * Context state for GL_ATI_fragment_shader 2219 */ 2220 struct gl_ati_fragment_shader_state 2221 { 2222 GLboolean Enabled; 2223 GLboolean _Enabled; /**< enabled and valid shader? */ 2224 GLboolean Compiling; 2225 GLfloat GlobalConstants[8][4]; 2226 struct ati_fragment_shader *Current; 2227 }; 2228 2229 /** 2230 * Shader subroutine function definition 2231 */ 2232 struct gl_subroutine_function 2233 { 2234 char *name; 2235 int index; 2236 int num_compat_types; 2237 const struct glsl_type **types; 2238 }; 2239 2240 /** 2241 * Shader information needed by both gl_shader and gl_linked shader. 2242 */ 2243 struct gl_shader_info 2244 { 2245 bool uses_gl_fragcoord; 2246 bool redeclares_gl_fragcoord; 2247 bool PostDepthCoverage; 2248 bool InnerCoverage; 2249 bool ARB_fragment_coord_conventions_enable; 2250 2251 /** 2252 * Fragment shader state from GLSL 1.50 layout qualifiers. 2253 */ 2254 bool origin_upper_left; 2255 bool pixel_center_integer; 2256 2257 struct { 2258 /** Global xfb_stride out qualifier if any */ 2259 GLuint BufferStride[MAX_FEEDBACK_BUFFERS]; 2260 } TransformFeedback; 2261 2262 /** 2263 * Tessellation Control shader state from layout qualifiers. 2264 */ 2265 struct { 2266 /** 2267 * 0 - vertices not declared in shader, or 2268 * 1 .. GL_MAX_PATCH_VERTICES 2269 */ 2270 GLint VerticesOut; 2271 } TessCtrl; 2272 2273 /** 2274 * Tessellation Evaluation shader state from layout qualifiers. 2275 */ 2276 struct { 2277 /** 2278 * GL_TRIANGLES, GL_QUADS, GL_ISOLINES or PRIM_UNKNOWN if it's not set 2279 * in this shader. 2280 */ 2281 GLenum PrimitiveMode; 2282 2283 enum gl_tess_spacing Spacing; 2284 2285 /** 2286 * GL_CW, GL_CCW, or 0 if it's not set in this shader. 2287 */ 2288 GLenum VertexOrder; 2289 /** 2290 * 1, 0, or -1 if it's not set in this shader. 2291 */ 2292 int PointMode; 2293 } TessEval; 2294 2295 /** 2296 * Geometry shader state from GLSL 1.50 layout qualifiers. 2297 */ 2298 struct { 2299 GLint VerticesOut; 2300 /** 2301 * 0 - Invocations count not declared in shader, or 2302 * 1 .. MAX_GEOMETRY_SHADER_INVOCATIONS 2303 */ 2304 GLint Invocations; 2305 /** 2306 * GL_POINTS, GL_LINES, GL_LINES_ADJACENCY, GL_TRIANGLES, or 2307 * GL_TRIANGLES_ADJACENCY, or PRIM_UNKNOWN if it's not set in this 2308 * shader. 2309 */ 2310 GLenum InputType; 2311 /** 2312 * GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP, or PRIM_UNKNOWN if 2313 * it's not set in this shader. 2314 */ 2315 GLenum OutputType; 2316 } Geom; 2317 2318 /** 2319 * Whether early fragment tests are enabled as defined by 2320 * ARB_shader_image_load_store. 2321 */ 2322 bool EarlyFragmentTests; 2323 2324 /** 2325 * Compute shader state from ARB_compute_shader and 2326 * ARB_compute_variable_group_size layout qualifiers. 2327 */ 2328 struct { 2329 /** 2330 * Size specified using local_size_{x,y,z}, or all 0's to indicate that 2331 * it's not set in this shader. 2332 */ 2333 unsigned LocalSize[3]; 2334 2335 /** 2336 * Whether a variable work group size has been specified as defined by 2337 * ARB_compute_variable_group_size. 2338 */ 2339 bool LocalSizeVariable; 2340 } Comp; 2341 }; 2342 2343 /** 2344 * A linked GLSL shader object. 2345 */ 2346 struct gl_linked_shader 2347 { 2348 gl_shader_stage Stage; 2349 2350 #ifdef DEBUG 2351 unsigned SourceChecksum; 2352 #endif 2353 2354 struct gl_program *Program; /**< Post-compile assembly code */ 2355 2356 /** 2357 * \name Sampler tracking 2358 * 2359 * \note Each of these fields is only set post-linking. 2360 */ 2361 /*@{*/ 2362 GLbitfield shadow_samplers; /**< Samplers used for shadow sampling. */ 2363 /*@}*/ 2364 2365 /** 2366 * Number of default uniform block components used by this shader. 2367 * 2368 * This field is only set post-linking. 2369 */ 2370 unsigned num_uniform_components; 2371 2372 /** 2373 * Number of combined uniform components used by this shader. 2374 * 2375 * This field is only set post-linking. It is the sum of the uniform block 2376 * sizes divided by sizeof(float), and num_uniform_compoennts. 2377 */ 2378 unsigned num_combined_uniform_components; 2379 2380 struct exec_list *ir; 2381 struct exec_list *packed_varyings; 2382 struct exec_list *fragdata_arrays; 2383 struct glsl_symbol_table *symbols; 2384 2385 struct gl_shader_info info; 2386 }; 2387 2388 static inline GLbitfield gl_external_samplers(struct gl_program *prog) 2389 { 2390 GLbitfield external_samplers = 0; 2391 GLbitfield mask = prog->SamplersUsed; 2392 2393 while (mask) { 2394 int idx = u_bit_scan(&mask); 2395 if (prog->sh.SamplerTargets[idx] == TEXTURE_EXTERNAL_INDEX) 2396 external_samplers |= (1 << idx); 2397 } 2398 2399 return external_samplers; 2400 } 2401 2402 /** 2403 * A GLSL shader object. 2404 */ 2405 struct gl_shader 2406 { 2407 /** GL_FRAGMENT_SHADER || GL_VERTEX_SHADER || GL_GEOMETRY_SHADER_ARB || 2408 * GL_TESS_CONTROL_SHADER || GL_TESS_EVALUATION_SHADER. 2409 * Must be the first field. 2410 */ 2411 GLenum Type; 2412 gl_shader_stage Stage; 2413 GLuint Name; /**< AKA the handle */ 2414 GLint RefCount; /**< Reference count */ 2415 GLchar *Label; /**< GL_KHR_debug */ 2416 GLboolean DeletePending; 2417 GLboolean CompileStatus; 2418 bool IsES; /**< True if this shader uses GLSL ES */ 2419 2420 #ifdef DEBUG 2421 unsigned SourceChecksum; /**< for debug/logging purposes */ 2422 #endif 2423 const GLchar *Source; /**< Source code string */ 2424 2425 GLchar *InfoLog; 2426 2427 unsigned Version; /**< GLSL version used for linking */ 2428 2429 struct exec_list *ir; 2430 struct glsl_symbol_table *symbols; 2431 2432 /** 2433 * A bitmask of gl_advanced_blend_mode values 2434 */ 2435 GLbitfield BlendSupport; 2436 2437 struct gl_shader_info info; 2438 }; 2439 2440 2441 struct gl_uniform_buffer_variable 2442 { 2443 char *Name; 2444 2445 /** 2446 * Name of the uniform as seen by glGetUniformIndices. 2447 * 2448 * glGetUniformIndices requires that the block instance index \b not be 2449 * present in the name of queried uniforms. 2450 * 2451 * \note 2452 * \c gl_uniform_buffer_variable::IndexName and 2453 * \c gl_uniform_buffer_variable::Name may point to identical storage. 2454 */ 2455 char *IndexName; 2456 2457 const struct glsl_type *Type; 2458 unsigned int Offset; 2459 GLboolean RowMajor; 2460 }; 2461 2462 2463 enum gl_uniform_block_packing 2464 { 2465 ubo_packing_std140, 2466 ubo_packing_shared, 2467 ubo_packing_packed, 2468 ubo_packing_std430 2469 }; 2470 2471 2472 struct gl_uniform_block 2473 { 2474 /** Declared name of the uniform block */ 2475 char *Name; 2476 2477 /** Array of supplemental information about UBO ir_variables. */ 2478 struct gl_uniform_buffer_variable *Uniforms; 2479 GLuint NumUniforms; 2480 2481 /** 2482 * Index (GL_UNIFORM_BLOCK_BINDING) into ctx->UniformBufferBindings[] to use 2483 * with glBindBufferBase to bind a buffer object to this uniform block. When 2484 * updated in the program, _NEW_BUFFER_OBJECT will be set. 2485 */ 2486 GLuint Binding; 2487 2488 /** 2489 * Minimum size (in bytes) of a buffer object to back this uniform buffer 2490 * (GL_UNIFORM_BLOCK_DATA_SIZE). 2491 */ 2492 GLuint UniformBufferSize; 2493 2494 /** Stages that reference this block */ 2495 uint8_t stageref; 2496 2497 /** 2498 * Linearized array index for uniform block instance arrays 2499 * 2500 * Given a uniform block instance array declared with size 2501 * blk[s_0][s_1]..[s_m], the block referenced by blk[i_0][i_1]..[i_m] will 2502 * have the linearized array index 2503 * 2504 * m-1 m 2505 * i_m + i_j * s_k 2506 * j=0 k=j+1 2507 * 2508 * For a uniform block instance that is not an array, this is always 0. 2509 */ 2510 uint8_t linearized_array_index; 2511 2512 /** 2513 * Layout specified in the shader 2514 * 2515 * This isn't accessible through the API, but it is used while 2516 * cross-validating uniform blocks. 2517 */ 2518 enum gl_uniform_block_packing _Packing; 2519 GLboolean _RowMajor; 2520 }; 2521 2522 /** 2523 * Structure that represents a reference to an atomic buffer from some 2524 * shader program. 2525 */ 2526 struct gl_active_atomic_buffer 2527 { 2528 /** Uniform indices of the atomic counters declared within it. */ 2529 GLuint *Uniforms; 2530 GLuint NumUniforms; 2531 2532 /** Binding point index associated with it. */ 2533 GLuint Binding; 2534 2535 /** Minimum reasonable size it is expected to have. */ 2536 GLuint MinimumSize; 2537 2538 /** Shader stages making use of it. */ 2539 GLboolean StageReferences[MESA_SHADER_STAGES]; 2540 }; 2541 2542 /** 2543 * Data container for shader queries. This holds only the minimal 2544 * amount of required information for resource queries to work. 2545 */ 2546 struct gl_shader_variable 2547 { 2548 /** 2549 * Declared type of the variable 2550 */ 2551 const struct glsl_type *type; 2552 2553 /** 2554 * If the variable is in an interface block, this is the type of the block. 2555 */ 2556 const struct glsl_type *interface_type; 2557 2558 /** 2559 * For variables inside structs (possibly recursively), this is the 2560 * outermost struct type. 2561 */ 2562 const struct glsl_type *outermost_struct_type; 2563 2564 /** 2565 * Declared name of the variable 2566 */ 2567 char *name; 2568 2569 /** 2570 * Storage location of the base of this variable 2571 * 2572 * The precise meaning of this field depends on the nature of the variable. 2573 * 2574 * - Vertex shader input: one of the values from \c gl_vert_attrib. 2575 * - Vertex shader output: one of the values from \c gl_varying_slot. 2576 * - Geometry shader input: one of the values from \c gl_varying_slot. 2577 * - Geometry shader output: one of the values from \c gl_varying_slot. 2578 * - Fragment shader input: one of the values from \c gl_varying_slot. 2579 * - Fragment shader output: one of the values from \c gl_frag_result. 2580 * - Uniforms: Per-stage uniform slot number for default uniform block. 2581 * - Uniforms: Index within the uniform block definition for UBO members. 2582 * - Non-UBO Uniforms: explicit location until linking then reused to 2583 * store uniform slot number. 2584 * - Other: This field is not currently used. 2585 * 2586 * If the variable is a uniform, shader input, or shader output, and the 2587 * slot has not been assigned, the value will be -1. 2588 */ 2589 int location; 2590 2591 /** 2592 * Specifies the first component the variable is stored in as per 2593 * ARB_enhanced_layouts. 2594 */ 2595 unsigned component:2; 2596 2597 /** 2598 * Output index for dual source blending. 2599 * 2600 * \note 2601 * The GLSL spec only allows the values 0 or 1 for the index in \b dual 2602 * source blending. 2603 */ 2604 unsigned index:1; 2605 2606 /** 2607 * Specifies whether a shader input/output is per-patch in tessellation 2608 * shader stages. 2609 */ 2610 unsigned patch:1; 2611 2612 /** 2613 * Storage class of the variable. 2614 * 2615 * \sa (n)ir_variable_mode 2616 */ 2617 unsigned mode:4; 2618 2619 /** 2620 * Interpolation mode for shader inputs / outputs 2621 * 2622 * \sa glsl_interp_mode 2623 */ 2624 unsigned interpolation:2; 2625 2626 /** 2627 * Was the location explicitly set in the shader? 2628 * 2629 * If the location is explicitly set in the shader, it \b cannot be changed 2630 * by the linker or by the API (e.g., calls to \c glBindAttribLocation have 2631 * no effect). 2632 */ 2633 unsigned explicit_location:1; 2634 2635 /** 2636 * Precision qualifier. 2637 */ 2638 unsigned precision:2; 2639 }; 2640 2641 /** 2642 * Active resource in a gl_shader_program 2643 */ 2644 struct gl_program_resource 2645 { 2646 GLenum Type; /** Program interface type. */ 2647 const void *Data; /** Pointer to resource associated data structure. */ 2648 uint8_t StageReferences; /** Bitmask of shader stage references. */ 2649 }; 2650 2651 /** 2652 * A data structure to be shared by gl_shader_program and gl_program. 2653 */ 2654 struct gl_shader_program_data 2655 { 2656 GLint RefCount; /**< Reference count */ 2657 2658 unsigned NumUniformStorage; 2659 unsigned NumHiddenUniforms; 2660 struct gl_uniform_storage *UniformStorage; 2661 2662 unsigned NumUniformBlocks; 2663 struct gl_uniform_block *UniformBlocks; 2664 2665 unsigned NumShaderStorageBlocks; 2666 struct gl_uniform_block *ShaderStorageBlocks; 2667 2668 struct gl_active_atomic_buffer *AtomicBuffers; 2669 unsigned NumAtomicBuffers; 2670 2671 GLboolean LinkStatus; /**< GL_LINK_STATUS */ 2672 GLboolean Validated; 2673 GLchar *InfoLog; 2674 2675 unsigned Version; /**< GLSL version used for linking */ 2676 2677 /* Mask of stages this program was linked against */ 2678 unsigned linked_stages; 2679 }; 2680 2681 /** 2682 * A GLSL program object. 2683 * Basically a linked collection of vertex and fragment shaders. 2684 */ 2685 struct gl_shader_program 2686 { 2687 GLenum Type; /**< Always GL_SHADER_PROGRAM (internal token) */ 2688 GLuint Name; /**< aka handle or ID */ 2689 GLchar *Label; /**< GL_KHR_debug */ 2690 GLint RefCount; /**< Reference count */ 2691 GLboolean DeletePending; 2692 2693 /** 2694 * Is the application intending to glGetProgramBinary this program? 2695 */ 2696 GLboolean BinaryRetreivableHint; 2697 2698 /** 2699 * Indicates whether program can be bound for individual pipeline stages 2700 * using UseProgramStages after it is next linked. 2701 */ 2702 GLboolean SeparateShader; 2703 2704 GLuint NumShaders; /**< number of attached shaders */ 2705 struct gl_shader **Shaders; /**< List of attached the shaders */ 2706 2707 /** 2708 * User-defined attribute bindings 2709 * 2710 * These are set via \c glBindAttribLocation and are used to direct the 2711 * GLSL linker. These are \b not the values used in the compiled shader, 2712 * and they are \b not the values returned by \c glGetAttribLocation. 2713 */ 2714 struct string_to_uint_map *AttributeBindings; 2715 2716 /** 2717 * User-defined fragment data bindings 2718 * 2719 * These are set via \c glBindFragDataLocation and are used to direct the 2720 * GLSL linker. These are \b not the values used in the compiled shader, 2721 * and they are \b not the values returned by \c glGetFragDataLocation. 2722 */ 2723 struct string_to_uint_map *FragDataBindings; 2724 struct string_to_uint_map *FragDataIndexBindings; 2725 2726 /** 2727 * Transform feedback varyings last specified by 2728 * glTransformFeedbackVaryings(). 2729 * 2730 * For the current set of transform feedback varyings used for transform 2731 * feedback output, see LinkedTransformFeedback. 2732 */ 2733 struct { 2734 GLenum BufferMode; 2735 /** Global xfb_stride out qualifier if any */ 2736 GLuint BufferStride[MAX_FEEDBACK_BUFFERS]; 2737 GLuint NumVarying; 2738 GLchar **VaryingNames; /**< Array [NumVarying] of char * */ 2739 } TransformFeedback; 2740 2741 struct gl_program *xfb_program; 2742 2743 /** Post-link gl_FragDepth layout for ARB_conservative_depth. */ 2744 enum gl_frag_depth_layout FragDepthLayout; 2745 2746 /** 2747 * Tessellation Evaluation shader state from layout qualifiers. 2748 */ 2749 struct { 2750 /** 2751 * True if gl_ClipDistance is written to. Copied into 2752 * gl_program by _mesa_copy_linked_program_data(). 2753 */ 2754 GLuint ClipDistanceArraySize; /**< Size of the gl_ClipDistance array, or 2755 0 if not present. */ 2756 GLuint CullDistanceArraySize; /**< Size of the gl_CullDistance array, or 2757 0 if not present. */ 2758 } TessEval; 2759 2760 /** 2761 * Geometry shader state - copied into gl_program by 2762 * _mesa_copy_linked_program_data(). 2763 */ 2764 struct { 2765 GLint VerticesIn; 2766 2767 /** 2768 * True if gl_ClipDistance is written to. Copied into 2769 * gl_program by _mesa_copy_linked_program_data(). 2770 */ 2771 GLuint ClipDistanceArraySize; /**< Size of the gl_ClipDistance array, or 2772 0 if not present. */ 2773 GLuint CullDistanceArraySize; /**< Size of the gl_CullDistance array, or 2774 0 if not present. */ 2775 bool UsesEndPrimitive; 2776 bool UsesStreams; 2777 } Geom; 2778 2779 /** Vertex shader state */ 2780 struct { 2781 /** 2782 * True if gl_ClipDistance is written to. Copied into gl_program 2783 * by _mesa_copy_linked_program_data(). 2784 */ 2785 GLuint ClipDistanceArraySize; /**< Size of the gl_ClipDistance array, or 2786 0 if not present. */ 2787 GLuint CullDistanceArraySize; /**< Size of the gl_CullDistance array, or 2788 0 if not present. */ 2789 } Vert; 2790 2791 /** 2792 * Compute shader state - copied into gl_program by 2793 * _mesa_copy_linked_program_data(). 2794 */ 2795 struct { 2796 /** 2797 * If this shader contains a compute stage, size specified using 2798 * local_size_{x,y,z}. Otherwise undefined. 2799 */ 2800 unsigned LocalSize[3]; 2801 /** 2802 * Size of shared variables accessed by the compute shader. 2803 */ 2804 unsigned SharedSize; 2805 2806 /** 2807 * Whether a variable work group size has been specified. 2808 */ 2809 bool LocalSizeVariable; 2810 } Comp; 2811 2812 /** Data shared by gl_program and gl_shader_program */ 2813 struct gl_shader_program_data *data; 2814 2815 /** 2816 * Mapping from GL uniform locations returned by \c glUniformLocation to 2817 * UniformStorage entries. Arrays will have multiple contiguous slots 2818 * in the UniformRemapTable, all pointing to the same UniformStorage entry. 2819 */ 2820 unsigned NumUniformRemapTable; 2821 struct gl_uniform_storage **UniformRemapTable; 2822 2823 /** 2824 * Sometimes there are empty slots left over in UniformRemapTable after we 2825 * allocate slots to explicit locations. This list stores the blocks of 2826 * continuous empty slots inside UniformRemapTable. 2827 */ 2828 struct exec_list EmptyUniformLocations; 2829 2830 /** 2831 * Size of the gl_ClipDistance array that is output from the last pipeline 2832 * stage before the fragment shader. 2833 */ 2834 unsigned LastClipDistanceArraySize; 2835 unsigned LastCullDistanceArraySize; 2836 2837 /** 2838 * Map of active uniform names to locations 2839 * 2840 * Maps any active uniform that is not an array element to a location. 2841 * Each active uniform, including individual structure members will appear 2842 * in this map. This roughly corresponds to the set of names that would be 2843 * enumerated by \c glGetActiveUniform. 2844 */ 2845 struct string_to_uint_map *UniformHash; 2846 2847 GLboolean SamplersValidated; /**< Samplers validated against texture units? */ 2848 2849 bool IsES; /**< True if this program uses GLSL ES */ 2850 2851 /** 2852 * Per-stage shaders resulting from the first stage of linking. 2853 * 2854 * Set of linked shaders for this program. The array is accessed using the 2855 * \c MESA_SHADER_* defines. Entries for non-existent stages will be 2856 * \c NULL. 2857 */ 2858 struct gl_linked_shader *_LinkedShaders[MESA_SHADER_STAGES]; 2859 2860 /** List of all active resources after linking. */ 2861 struct gl_program_resource *ProgramResourceList; 2862 unsigned NumProgramResourceList; 2863 2864 /* True if any of the fragment shaders attached to this program use: 2865 * #extension ARB_fragment_coord_conventions: enable 2866 */ 2867 GLboolean ARB_fragment_coord_conventions_enable; 2868 }; 2869 2870 2871 #define GLSL_DUMP 0x1 /**< Dump shaders to stdout */ 2872 #define GLSL_LOG 0x2 /**< Write shaders to files */ 2873 #define GLSL_OPT 0x4 /**< Force optimizations (override pragmas) */ 2874 #define GLSL_NO_OPT 0x8 /**< Force no optimizations (override pragmas) */ 2875 #define GLSL_UNIFORMS 0x10 /**< Print glUniform calls */ 2876 #define GLSL_NOP_VERT 0x20 /**< Force no-op vertex shaders */ 2877 #define GLSL_NOP_FRAG 0x40 /**< Force no-op fragment shaders */ 2878 #define GLSL_USE_PROG 0x80 /**< Log glUseProgram calls */ 2879 #define GLSL_REPORT_ERRORS 0x100 /**< Print compilation errors */ 2880 #define GLSL_DUMP_ON_ERROR 0x200 /**< Dump shaders to stderr on compile error */ 2881 2882 2883 /** 2884 * Context state for GLSL vertex/fragment shaders. 2885 * Extended to support pipeline object 2886 */ 2887 struct gl_pipeline_object 2888 { 2889 /** Name of the pipeline object as received from glGenProgramPipelines. 2890 * It would be 0 for shaders without separate shader objects. 2891 */ 2892 GLuint Name; 2893 2894 GLint RefCount; 2895 2896 mtx_t Mutex; 2897 2898 GLchar *Label; /**< GL_KHR_debug */ 2899 2900 /** 2901 * Programs used for rendering 2902 * 2903 * There is a separate program set for each shader stage. 2904 */ 2905 struct gl_shader_program *CurrentProgram[MESA_SHADER_STAGES]; 2906 2907 struct gl_program *_CurrentFragmentProgram; 2908 2909 /** 2910 * Program used by glUniform calls. 2911 * 2912 * Explicitly set by \c glUseProgram and \c glActiveProgramEXT. 2913 */ 2914 struct gl_shader_program *ActiveProgram; 2915 2916 GLbitfield Flags; /**< Mask of GLSL_x flags */ 2917 2918 GLboolean EverBound; /**< Has the pipeline object been created */ 2919 2920 GLboolean Validated; /**< Pipeline Validation status */ 2921 2922 GLchar *InfoLog; 2923 }; 2924 2925 /** 2926 * Context state for GLSL pipeline shaders. 2927 */ 2928 struct gl_pipeline_shader_state 2929 { 2930 /** Currently bound pipeline object. See _mesa_BindProgramPipeline() */ 2931 struct gl_pipeline_object *Current; 2932 2933 /* Default Object to ensure that _Shader is never NULL */ 2934 struct gl_pipeline_object *Default; 2935 2936 /** Pipeline objects */ 2937 struct _mesa_HashTable *Objects; 2938 }; 2939 2940 /** 2941 * Compiler options for a single GLSL shaders type 2942 */ 2943 struct gl_shader_compiler_options 2944 { 2945 /** Driver-selectable options: */ 2946 GLboolean EmitNoLoops; 2947 GLboolean EmitNoFunctions; 2948 GLboolean EmitNoCont; /**< Emit CONT opcode? */ 2949 GLboolean EmitNoMainReturn; /**< Emit CONT/RET opcodes? */ 2950 GLboolean EmitNoPow; /**< Emit POW opcodes? */ 2951 GLboolean EmitNoSat; /**< Emit SAT opcodes? */ 2952 GLboolean LowerCombinedClipCullDistance; /** Lower gl_ClipDistance and 2953 * gl_CullDistance together from 2954 * float[8] to vec4[2] 2955 **/ 2956 2957 /** 2958 * \name Forms of indirect addressing the driver cannot do. 2959 */ 2960 /*@{*/ 2961 GLboolean EmitNoIndirectInput; /**< No indirect addressing of inputs */ 2962 GLboolean EmitNoIndirectOutput; /**< No indirect addressing of outputs */ 2963 GLboolean EmitNoIndirectTemp; /**< No indirect addressing of temps */ 2964 GLboolean EmitNoIndirectUniform; /**< No indirect addressing of constants */ 2965 GLboolean EmitNoIndirectSampler; /**< No indirect addressing of samplers */ 2966 /*@}*/ 2967 2968 GLuint MaxIfDepth; /**< Maximum nested IF blocks */ 2969 GLuint MaxUnrollIterations; 2970 2971 /** 2972 * Optimize code for array of structures backends. 2973 * 2974 * This is a proxy for: 2975 * - preferring DP4 instructions (rather than MUL/MAD) for 2976 * matrix * vector operations, such as position transformation. 2977 */ 2978 GLboolean OptimizeForAOS; 2979 2980 GLboolean LowerBufferInterfaceBlocks; /**< Lower UBO and SSBO access to intrinsics. */ 2981 2982 /** Clamp UBO and SSBO block indices so they don't go out-of-bounds. */ 2983 GLboolean ClampBlockIndicesToArrayBounds; 2984 2985 const struct nir_shader_compiler_options *NirOptions; 2986 }; 2987 2988 2989 /** 2990 * Occlusion/timer query object. 2991 */ 2992 struct gl_query_object 2993 { 2994 GLenum Target; /**< The query target, when active */ 2995 GLuint Id; /**< hash table ID/name */ 2996 GLchar *Label; /**< GL_KHR_debug */ 2997 GLuint64EXT Result; /**< the counter */ 2998 GLboolean Active; /**< inside Begin/EndQuery */ 2999 GLboolean Ready; /**< result is ready? */ 3000 GLboolean EverBound;/**< has query object ever been bound */ 3001 GLuint Stream; /**< The stream */ 3002 }; 3003 3004 3005 /** 3006 * Context state for query objects. 3007 */ 3008 struct gl_query_state 3009 { 3010 struct _mesa_HashTable *QueryObjects; 3011 struct gl_query_object *CurrentOcclusionObject; /* GL_ARB_occlusion_query */ 3012 struct gl_query_object *CurrentTimerObject; /* GL_EXT_timer_query */ 3013 3014 /** GL_NV_conditional_render */ 3015 struct gl_query_object *CondRenderQuery; 3016 3017 /** GL_EXT_transform_feedback */ 3018 struct gl_query_object *PrimitivesGenerated[MAX_VERTEX_STREAMS]; 3019 struct gl_query_object *PrimitivesWritten[MAX_VERTEX_STREAMS]; 3020 3021 /** GL_ARB_timer_query */ 3022 struct gl_query_object *TimeElapsed; 3023 3024 /** GL_ARB_pipeline_statistics_query */ 3025 struct gl_query_object *pipeline_stats[MAX_PIPELINE_STATISTICS]; 3026 3027 GLenum CondRenderMode; 3028 }; 3029 3030 3031 /** Sync object state */ 3032 struct gl_sync_object 3033 { 3034 GLenum Type; /**< GL_SYNC_FENCE */ 3035 GLuint Name; /**< Fence name */ 3036 GLchar *Label; /**< GL_KHR_debug */ 3037 GLint RefCount; /**< Reference count */ 3038 GLboolean DeletePending; /**< Object was deleted while there were still 3039 * live references (e.g., sync not yet finished) 3040 */ 3041 GLenum SyncCondition; 3042 GLbitfield Flags; /**< Flags passed to glFenceSync */ 3043 GLuint StatusFlag:1; /**< Has the sync object been signaled? */ 3044 }; 3045 3046 3047 /** 3048 * State which can be shared by multiple contexts: 3049 */ 3050 struct gl_shared_state 3051 { 3052 mtx_t Mutex; /**< for thread safety */ 3053 GLint RefCount; /**< Reference count */ 3054 struct _mesa_HashTable *DisplayList; /**< Display lists hash table */ 3055 struct _mesa_HashTable *BitmapAtlas; /**< For optimized glBitmap text */ 3056 struct _mesa_HashTable *TexObjects; /**< Texture objects hash table */ 3057 3058 /** Default texture objects (shared by all texture units) */ 3059 struct gl_texture_object *DefaultTex[NUM_TEXTURE_TARGETS]; 3060 3061 /** Fallback texture used when a bound texture is incomplete */ 3062 struct gl_texture_object *FallbackTex[NUM_TEXTURE_TARGETS]; 3063 3064 /** 3065 * \name Thread safety and statechange notification for texture 3066 * objects. 3067 * 3068 * \todo Improve the granularity of locking. 3069 */ 3070 /*@{*/ 3071 mtx_t TexMutex; /**< texobj thread safety */ 3072 GLuint TextureStateStamp; /**< state notification for shared tex */ 3073 /*@}*/ 3074 3075 /** Default buffer object for vertex arrays that aren't in VBOs */ 3076 struct gl_buffer_object *NullBufferObj; 3077 3078 /** 3079 * \name Vertex/geometry/fragment programs 3080 */ 3081 /*@{*/ 3082 struct _mesa_HashTable *Programs; /**< All vertex/fragment programs */ 3083 struct gl_program *DefaultVertexProgram; 3084 struct gl_program *DefaultFragmentProgram; 3085 /*@}*/ 3086 3087 /* GL_ATI_fragment_shader */ 3088 struct _mesa_HashTable *ATIShaders; 3089 struct ati_fragment_shader *DefaultFragmentShader; 3090 3091 struct _mesa_HashTable *BufferObjects; 3092 3093 /** Table of both gl_shader and gl_shader_program objects */ 3094 struct _mesa_HashTable *ShaderObjects; 3095 3096 /* GL_EXT_framebuffer_object */ 3097 struct _mesa_HashTable *RenderBuffers; 3098 struct _mesa_HashTable *FrameBuffers; 3099 3100 /* GL_ARB_sync */ 3101 struct set *SyncObjects; 3102 3103 /** GL_ARB_sampler_objects */ 3104 struct _mesa_HashTable *SamplerObjects; 3105 3106 /** 3107 * Some context in this share group was affected by a GPU reset 3108 * 3109 * On the next call to \c glGetGraphicsResetStatus, contexts that have not 3110 * been affected by a GPU reset must also return 3111 * \c GL_INNOCENT_CONTEXT_RESET_ARB. 3112 * 3113 * Once this field becomes true, it is never reset to false. 3114 */ 3115 bool ShareGroupReset; 3116 }; 3117 3118 3119 3120 /** 3121 * Renderbuffers represent drawing surfaces such as color, depth and/or 3122 * stencil. A framebuffer object has a set of renderbuffers. 3123 * Drivers will typically derive subclasses of this type. 3124 */ 3125 struct gl_renderbuffer 3126 { 3127 mtx_t Mutex; /**< for thread safety */ 3128 GLuint ClassID; /**< Useful for drivers */ 3129 GLuint Name; 3130 GLchar *Label; /**< GL_KHR_debug */ 3131 GLint RefCount; 3132 GLuint Width, Height; 3133 GLuint Depth; 3134 GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */ 3135 GLboolean AttachedAnytime; /**< TRUE if it was attached to a framebuffer */ 3136 /** 3137 * True for renderbuffers that wrap textures, giving the driver a chance to 3138 * flush render caches through the FinishRenderTexture hook. 3139 * 3140 * Drivers may also set this on renderbuffers other than those generated by 3141 * glFramebufferTexture(), though it means FinishRenderTexture() would be 3142 * called without a rb->TexImage. 3143 */ 3144 GLboolean NeedsFinishRenderTexture; 3145 GLubyte NumSamples; 3146 GLenum InternalFormat; /**< The user-specified format */ 3147 GLenum _BaseFormat; /**< Either GL_RGB, GL_RGBA, GL_DEPTH_COMPONENT or 3148 GL_STENCIL_INDEX. */ 3149 mesa_format Format; /**< The actual renderbuffer memory format */ 3150 /** 3151 * Pointer to the texture image if this renderbuffer wraps a texture, 3152 * otherwise NULL. 3153 * 3154 * Note that the reference on the gl_texture_object containing this 3155 * TexImage is held by the gl_renderbuffer_attachment. 3156 */ 3157 struct gl_texture_image *TexImage; 3158 3159 /** Delete this renderbuffer */ 3160 void (*Delete)(struct gl_context *ctx, struct gl_renderbuffer *rb); 3161 3162 /** Allocate new storage for this renderbuffer */ 3163 GLboolean (*AllocStorage)(struct gl_context *ctx, 3164 struct gl_renderbuffer *rb, 3165 GLenum internalFormat, 3166 GLuint width, GLuint height); 3167 }; 3168 3169 3170 /** 3171 * A renderbuffer attachment points to either a texture object (and specifies 3172 * a mipmap level, cube face or 3D texture slice) or points to a renderbuffer. 3173 */ 3174 struct gl_renderbuffer_attachment 3175 { 3176 GLenum Type; /**< \c GL_NONE or \c GL_TEXTURE or \c GL_RENDERBUFFER_EXT */ 3177 GLboolean Complete; 3178 3179 /** 3180 * If \c Type is \c GL_RENDERBUFFER_EXT, this stores a pointer to the 3181 * application supplied renderbuffer object. 3182 */ 3183 struct gl_renderbuffer *Renderbuffer; 3184 3185 /** 3186 * If \c Type is \c GL_TEXTURE, this stores a pointer to the application 3187 * supplied texture object. 3188 */ 3189 struct gl_texture_object *Texture; 3190 GLuint TextureLevel; /**< Attached mipmap level. */ 3191 GLuint CubeMapFace; /**< 0 .. 5, for cube map textures. */ 3192 GLuint Zoffset; /**< Slice for 3D textures, or layer for both 1D 3193 * and 2D array textures */ 3194 GLboolean Layered; 3195 }; 3196 3197 3198 /** 3199 * A framebuffer is a collection of renderbuffers (color, depth, stencil, etc). 3200 * In C++ terms, think of this as a base class from which device drivers 3201 * will make derived classes. 3202 */ 3203 struct gl_framebuffer 3204 { 3205 mtx_t Mutex; /**< for thread safety */ 3206 /** 3207 * If zero, this is a window system framebuffer. If non-zero, this 3208 * is a FBO framebuffer; note that for some devices (i.e. those with 3209 * a natural pixel coordinate system for FBOs that differs from the 3210 * OpenGL/Mesa coordinate system), this means that the viewport, 3211 * polygon face orientation, and polygon stipple will have to be inverted. 3212 */ 3213 GLuint Name; 3214 GLint RefCount; 3215 3216 GLchar *Label; /**< GL_KHR_debug */ 3217 3218 GLboolean DeletePending; 3219 3220 /** 3221 * The framebuffer's visual. Immutable if this is a window system buffer. 3222 * Computed from attachments if user-made FBO. 3223 */ 3224 struct gl_config Visual; 3225 3226 /** 3227 * Size of frame buffer in pixels. If there are no attachments, then both 3228 * of these are 0. 3229 */ 3230 GLuint Width, Height; 3231 3232 /** 3233 * In the case that the framebuffer has no attachment (i.e. 3234 * GL_ARB_framebuffer_no_attachments) then the geometry of 3235 * the framebuffer is specified by the default values. 3236 */ 3237 struct { 3238 GLuint Width, Height, Layers, NumSamples; 3239 GLboolean FixedSampleLocations; 3240 /* Derived from NumSamples by the driver so that it can choose a valid 3241 * value for the hardware. 3242 */ 3243 GLuint _NumSamples; 3244 } DefaultGeometry; 3245 3246 /** \name Drawing bounds (Intersection of buffer size and scissor box) 3247 * The drawing region is given by [_Xmin, _Xmax) x [_Ymin, _Ymax), 3248 * (inclusive for _Xmin and _Ymin while exclusive for _Xmax and _Ymax) 3249 */ 3250 /*@{*/ 3251 GLint _Xmin, _Xmax; 3252 GLint _Ymin, _Ymax; 3253 /*@}*/ 3254 3255 /** \name Derived Z buffer stuff */ 3256 /*@{*/ 3257 GLuint _DepthMax; /**< Max depth buffer value */ 3258 GLfloat _DepthMaxF; /**< Float max depth buffer value */ 3259 GLfloat _MRD; /**< minimum resolvable difference in Z values */ 3260 /*@}*/ 3261 3262 /** One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */ 3263 GLenum _Status; 3264 3265 /** Whether one of Attachment has Type != GL_NONE 3266 * NOTE: the values for Width and Height are set to 0 in case of having 3267 * no attachments, a backend driver supporting the extension 3268 * GL_ARB_framebuffer_no_attachments must check for the flag _HasAttachments 3269 * and if GL_FALSE, must then use the values in DefaultGeometry to initialize 3270 * its viewport, scissor and so on (in particular _Xmin, _Xmax, _Ymin and 3271 * _Ymax do NOT take into account _HasAttachments being false). To get the 3272 * geometry of the framebuffer, the helper functions 3273 * _mesa_geometric_width(), 3274 * _mesa_geometric_height(), 3275 * _mesa_geometric_samples() and 3276 * _mesa_geometric_layers() 3277 * are available that check _HasAttachments. 3278 */ 3279 bool _HasAttachments; 3280 3281 GLbitfield _IntegerBuffers; /**< Which color buffers are integer valued */ 3282 3283 /* ARB_color_buffer_float */ 3284 GLboolean _AllColorBuffersFixedPoint; /* no integer, no float */ 3285 GLboolean _HasSNormOrFloatColorBuffer; 3286 3287 /** 3288 * The maximum number of layers in the framebuffer, or 0 if the framebuffer 3289 * is not layered. For cube maps and cube map arrays, each cube face 3290 * counts as a layer. As the case for Width, Height a backend driver 3291 * supporting GL_ARB_framebuffer_no_attachments must use DefaultGeometry 3292 * in the case that _HasAttachments is false 3293 */ 3294 GLuint MaxNumLayers; 3295 3296 /** Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */ 3297 struct gl_renderbuffer_attachment Attachment[BUFFER_COUNT]; 3298 3299 /* In unextended OpenGL these vars are part of the GL_COLOR_BUFFER 3300 * attribute group and GL_PIXEL attribute group, respectively. 3301 */ 3302 GLenum ColorDrawBuffer[MAX_DRAW_BUFFERS]; 3303 GLenum ColorReadBuffer; 3304 3305 /** Computed from ColorDraw/ReadBuffer above */ 3306 GLuint _NumColorDrawBuffers; 3307 GLint _ColorDrawBufferIndexes[MAX_DRAW_BUFFERS]; /**< BUFFER_x or -1 */ 3308 GLint _ColorReadBufferIndex; /* -1 = None */ 3309 struct gl_renderbuffer *_ColorDrawBuffers[MAX_DRAW_BUFFERS]; 3310 struct gl_renderbuffer *_ColorReadBuffer; 3311 3312 /** Delete this framebuffer */ 3313 void (*Delete)(struct gl_framebuffer *fb); 3314 }; 3315 3316 3317 /** 3318 * Precision info for shader datatypes. See glGetShaderPrecisionFormat(). 3319 */ 3320 struct gl_precision 3321 { 3322 GLushort RangeMin; /**< min value exponent */ 3323 GLushort RangeMax; /**< max value exponent */ 3324 GLushort Precision; /**< number of mantissa bits */ 3325 }; 3326 3327 3328 /** 3329 * Limits for vertex, geometry and fragment programs/shaders. 3330 */ 3331 struct gl_program_constants 3332 { 3333 /* logical limits */ 3334 GLuint MaxInstructions; 3335 GLuint MaxAluInstructions; 3336 GLuint MaxTexInstructions; 3337 GLuint MaxTexIndirections; 3338 GLuint MaxAttribs; 3339 GLuint MaxTemps; 3340 GLuint MaxAddressRegs; 3341 GLuint MaxAddressOffset; /**< [-MaxAddressOffset, MaxAddressOffset-1] */ 3342 GLuint MaxParameters; 3343 GLuint MaxLocalParams; 3344 GLuint MaxEnvParams; 3345 /* native/hardware limits */ 3346 GLuint MaxNativeInstructions; 3347 GLuint MaxNativeAluInstructions; 3348 GLuint MaxNativeTexInstructions; 3349 GLuint MaxNativeTexIndirections; 3350 GLuint MaxNativeAttribs; 3351 GLuint MaxNativeTemps; 3352 GLuint MaxNativeAddressRegs; 3353 GLuint MaxNativeParameters; 3354 /* For shaders */ 3355 GLuint MaxUniformComponents; /**< Usually == MaxParameters * 4 */ 3356 3357 /** 3358 * \name Per-stage input / output limits 3359 * 3360 * Previous to OpenGL 3.2, the intrastage data limits were advertised with 3361 * a single value: GL_MAX_VARYING_COMPONENTS (GL_MAX_VARYING_VECTORS in 3362 * ES). This is stored as \c gl_constants::MaxVarying. 3363 * 3364 * Starting with OpenGL 3.2, the limits are advertised with per-stage 3365 * variables. Each stage as a certain number of outputs that it can feed 3366 * to the next stage and a certain number inputs that it can consume from 3367 * the previous stage. 3368 * 3369 * Vertex shader inputs do not participate this in this accounting. 3370 * These are tracked exclusively by \c gl_program_constants::MaxAttribs. 3371 * 3372 * Fragment shader outputs do not participate this in this accounting. 3373 * These are tracked exclusively by \c gl_constants::MaxDrawBuffers. 3374 */ 3375 /*@{*/ 3376 GLuint MaxInputComponents; 3377 GLuint MaxOutputComponents; 3378 /*@}*/ 3379 3380 /* ES 2.0 and GL_ARB_ES2_compatibility */ 3381 struct gl_precision LowFloat, MediumFloat, HighFloat; 3382 struct gl_precision LowInt, MediumInt, HighInt; 3383 /* GL_ARB_uniform_buffer_object */ 3384 GLuint MaxUniformBlocks; 3385 GLuint MaxCombinedUniformComponents; 3386 GLuint MaxTextureImageUnits; 3387 3388 /* GL_ARB_shader_atomic_counters */ 3389 GLuint MaxAtomicBuffers; 3390 GLuint MaxAtomicCounters; 3391 3392 /* GL_ARB_shader_image_load_store */ 3393 GLuint MaxImageUniforms; 3394 3395 /* GL_ARB_shader_storage_buffer_object */ 3396 GLuint MaxShaderStorageBlocks; 3397 }; 3398 3399 3400 /** 3401 * Constants which may be overridden by device driver during context creation 3402 * but are never changed after that. 3403 */ 3404 struct gl_constants 3405 { 3406 GLuint MaxTextureMbytes; /**< Max memory per image, in MB */ 3407 GLuint MaxTextureLevels; /**< Max mipmap levels. */ 3408 GLuint Max3DTextureLevels; /**< Max mipmap levels for 3D textures */ 3409 GLuint MaxCubeTextureLevels; /**< Max mipmap levels for cube textures */ 3410 GLuint MaxArrayTextureLayers; /**< Max layers in array textures */ 3411 GLuint MaxTextureRectSize; /**< Max rectangle texture size, in pixes */ 3412 GLuint MaxTextureCoordUnits; 3413 GLuint MaxCombinedTextureImageUnits; 3414 GLuint MaxTextureUnits; /**< = MIN(CoordUnits, FragmentProgram.ImageUnits) */ 3415 GLfloat MaxTextureMaxAnisotropy; /**< GL_EXT_texture_filter_anisotropic */ 3416 GLfloat MaxTextureLodBias; /**< GL_EXT_texture_lod_bias */ 3417 GLuint MaxTextureBufferSize; /**< GL_ARB_texture_buffer_object */ 3418 3419 GLuint TextureBufferOffsetAlignment; /**< GL_ARB_texture_buffer_range */ 3420 3421 GLuint MaxArrayLockSize; 3422 3423 GLint SubPixelBits; 3424 3425 GLfloat MinPointSize, MaxPointSize; /**< aliased */ 3426 GLfloat MinPointSizeAA, MaxPointSizeAA; /**< antialiased */ 3427 GLfloat PointSizeGranularity; 3428 GLfloat MinLineWidth, MaxLineWidth; /**< aliased */ 3429 GLfloat MinLineWidthAA, MaxLineWidthAA; /**< antialiased */ 3430 GLfloat LineWidthGranularity; 3431 3432 GLuint MaxClipPlanes; 3433 GLuint MaxLights; 3434 GLfloat MaxShininess; /**< GL_NV_light_max_exponent */ 3435 GLfloat MaxSpotExponent; /**< GL_NV_light_max_exponent */ 3436 3437 GLuint MaxViewportWidth, MaxViewportHeight; 3438 GLuint MaxViewports; /**< GL_ARB_viewport_array */ 3439 GLuint ViewportSubpixelBits; /**< GL_ARB_viewport_array */ 3440 struct { 3441 GLfloat Min; 3442 GLfloat Max; 3443 } ViewportBounds; /**< GL_ARB_viewport_array */ 3444 GLuint MaxWindowRectangles; /**< GL_EXT_window_rectangles */ 3445 3446 struct gl_program_constants Program[MESA_SHADER_STAGES]; 3447 GLuint MaxProgramMatrices; 3448 GLuint MaxProgramMatrixStackDepth; 3449 3450 struct { 3451 GLuint SamplesPassed; 3452 GLuint TimeElapsed; 3453 GLuint Timestamp; 3454 GLuint PrimitivesGenerated; 3455 GLuint PrimitivesWritten; 3456 GLuint VerticesSubmitted; 3457 GLuint PrimitivesSubmitted; 3458 GLuint VsInvocations; 3459 GLuint TessPatches; 3460 GLuint TessInvocations; 3461 GLuint GsInvocations; 3462 GLuint GsPrimitives; 3463 GLuint FsInvocations; 3464 GLuint ComputeInvocations; 3465 GLuint ClInPrimitives; 3466 GLuint ClOutPrimitives; 3467 } QueryCounterBits; 3468 3469 GLuint MaxDrawBuffers; /**< GL_ARB_draw_buffers */ 3470 3471 GLuint MaxColorAttachments; /**< GL_EXT_framebuffer_object */ 3472 GLuint MaxRenderbufferSize; /**< GL_EXT_framebuffer_object */ 3473 GLuint MaxSamples; /**< GL_ARB_framebuffer_object */ 3474 3475 /** 3476 * GL_ARB_framebuffer_no_attachments 3477 */ 3478 GLuint MaxFramebufferWidth; 3479 GLuint MaxFramebufferHeight; 3480 GLuint MaxFramebufferLayers; 3481 GLuint MaxFramebufferSamples; 3482 3483 /** Number of varying vectors between any two shader stages. */ 3484 GLuint MaxVarying; 3485 3486 /** @{ 3487 * GL_ARB_uniform_buffer_object 3488 */ 3489 GLuint MaxCombinedUniformBlocks; 3490 GLuint MaxUniformBufferBindings; 3491 GLuint MaxUniformBlockSize; 3492 GLuint UniformBufferOffsetAlignment; 3493 /** @} */ 3494 3495 /** @{ 3496 * GL_ARB_shader_storage_buffer_object 3497 */ 3498 GLuint MaxCombinedShaderStorageBlocks; 3499 GLuint MaxShaderStorageBufferBindings; 3500 GLuint MaxShaderStorageBlockSize; 3501 GLuint ShaderStorageBufferOffsetAlignment; 3502 /** @} */ 3503 3504 /** 3505 * GL_ARB_explicit_uniform_location 3506 */ 3507 GLuint MaxUserAssignableUniformLocations; 3508 3509 /** geometry shader */ 3510 GLuint MaxGeometryOutputVertices; 3511 GLuint MaxGeometryTotalOutputComponents; 3512 3513 GLuint GLSLVersion; /**< Desktop GLSL version supported (ex: 120 = 1.20) */ 3514 3515 /** 3516 * Changes default GLSL extension behavior from "error" to "warn". It's out 3517 * of spec, but it can make some apps work that otherwise wouldn't. 3518 */ 3519 GLboolean ForceGLSLExtensionsWarn; 3520 3521 /** 3522 * If non-zero, forces GLSL shaders to behave as if they began 3523 * with "#version ForceGLSLVersion". 3524 */ 3525 GLuint ForceGLSLVersion; 3526 3527 /** 3528 * Allow GLSL #extension directives in the middle of shaders. 3529 */ 3530 GLboolean AllowGLSLExtensionDirectiveMidShader; 3531 3532 /** 3533 * Force uninitialized variables to default to zero. 3534 */ 3535 GLboolean GLSLZeroInit; 3536 3537 /** 3538 * Does the driver support real 32-bit integers? (Otherwise, integers are 3539 * simulated via floats.) 3540 */ 3541 GLboolean NativeIntegers; 3542 3543 /** 3544 * Does VertexID count from zero or from base vertex? 3545 * 3546 * \note 3547 * If desktop GLSL 1.30 or GLSL ES 3.00 are not supported, this field is 3548 * ignored and need not be set. 3549 */ 3550 bool VertexID_is_zero_based; 3551 3552 /** 3553 * If the driver supports real 32-bit integers, what integer value should be 3554 * used for boolean true in uniform uploads? (Usually 1 or ~0.) 3555 */ 3556 GLuint UniformBooleanTrue; 3557 3558 /** 3559 * Maximum amount of time, measured in nanseconds, that the server can wait. 3560 */ 3561 GLuint64 MaxServerWaitTimeout; 3562 3563 /** GL_EXT_provoking_vertex */ 3564 GLboolean QuadsFollowProvokingVertexConvention; 3565 3566 /** GL_ARB_viewport_array */ 3567 GLenum LayerAndVPIndexProvokingVertex; 3568 3569 /** OpenGL version 3.0 */ 3570 GLbitfield ContextFlags; /**< Ex: GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */ 3571 3572 /** OpenGL version 3.2 */ 3573 GLbitfield ProfileMask; /**< Mask of CONTEXT_x_PROFILE_BIT */ 3574 3575 /** OpenGL version 4.4 */ 3576 GLuint MaxVertexAttribStride; 3577 3578 /** GL_EXT_transform_feedback */ 3579 GLuint MaxTransformFeedbackBuffers; 3580 GLuint MaxTransformFeedbackSeparateComponents; 3581 GLuint MaxTransformFeedbackInterleavedComponents; 3582 GLuint MaxVertexStreams; 3583 3584 /** GL_EXT_gpu_shader4 */ 3585 GLint MinProgramTexelOffset, MaxProgramTexelOffset; 3586 3587 /** GL_ARB_texture_gather */ 3588 GLuint MinProgramTextureGatherOffset; 3589 GLuint MaxProgramTextureGatherOffset; 3590 GLuint MaxProgramTextureGatherComponents; 3591 3592 /* GL_ARB_robustness */ 3593 GLenum ResetStrategy; 3594 3595 /* GL_KHR_robustness */ 3596 GLboolean RobustAccess; 3597 3598 /* GL_ARB_blend_func_extended */ 3599 GLuint MaxDualSourceDrawBuffers; 3600 3601 /** 3602 * Whether the implementation strips out and ignores texture borders. 3603 * 3604 * Many GPU hardware implementations don't support rendering with texture 3605 * borders and mipmapped textures. (Note: not static border color, but the 3606 * old 1-pixel border around each edge). Implementations then have to do 3607 * slow fallbacks to be correct, or just ignore the border and be fast but 3608 * wrong. Setting the flag strips the border off of TexImage calls, 3609 * providing "fast but wrong" at significantly reduced driver complexity. 3610 * 3611 * Texture borders are deprecated in GL 3.0. 3612 **/ 3613 GLboolean StripTextureBorder; 3614 3615 /** 3616 * For drivers which can do a better job at eliminating unused uniforms 3617 * than the GLSL compiler. 3618 * 3619 * XXX Remove these as soon as a better solution is available. 3620 */ 3621 GLboolean GLSLSkipStrictMaxUniformLimitCheck; 3622 3623 /** Whether gl_FragCoord and gl_FrontFacing are system values. */ 3624 bool GLSLFragCoordIsSysVal; 3625 bool GLSLFrontFacingIsSysVal; 3626 3627 /** 3628 * Run the minimum amount of GLSL optimizations to be able to link 3629 * shaders optimally (eliminate dead varyings and uniforms) and just do 3630 * all the necessary lowering. 3631 */ 3632 bool GLSLOptimizeConservatively; 3633 3634 /** 3635 * True if gl_TessLevelInner/Outer[] in the TES should be inputs 3636 * (otherwise, they're system values). 3637 */ 3638 bool GLSLTessLevelsAsInputs; 3639 3640 /** 3641 * Always use the GetTransformFeedbackVertexCount() driver hook, rather 3642 * than passing the transform feedback object to the drawing function. 3643 */ 3644 GLboolean AlwaysUseGetTransformFeedbackVertexCount; 3645 3646 /** GL_ARB_map_buffer_alignment */ 3647 GLuint MinMapBufferAlignment; 3648 3649 /** 3650 * Disable varying packing. This is out of spec, but potentially useful 3651 * for older platforms that supports a limited number of texture 3652 * indirections--on these platforms, unpacking the varyings in the fragment 3653 * shader increases the number of texture indirections by 1, which might 3654 * make some shaders not executable at all. 3655 * 3656 * Drivers that support transform feedback must set this value to GL_FALSE. 3657 */ 3658 GLboolean DisableVaryingPacking; 3659 3660 /** 3661 * Should meaningful names be generated for compiler temporary variables? 3662 * 3663 * Generally, it is not useful to have the compiler generate "meaningful" 3664 * names for temporary variables that it creates. This can, however, be a 3665 * useful debugging aid. In Mesa debug builds or release builds when 3666 * MESA_GLSL is set at run-time, meaningful names will be generated. 3667 * Drivers can also force names to be generated by setting this field. 3668 * For example, the i965 driver may set it when INTEL_DEBUG=vs (to dump 3669 * vertex shader assembly) is set at run-time. 3670 */ 3671 bool GenerateTemporaryNames; 3672 3673 /* 3674 * Maximum value supported for an index in DrawElements and friends. 3675 * 3676 * This must be at least (1ull<<24)-1. The default value is 3677 * (1ull<<32)-1. 3678 * 3679 * \since ES 3.0 or GL_ARB_ES3_compatibility 3680 * \sa _mesa_init_constants 3681 */ 3682 GLuint64 MaxElementIndex; 3683 3684 /** 3685 * Disable interpretation of line continuations (lines ending with a 3686 * backslash character ('\') in GLSL source. 3687 */ 3688 GLboolean DisableGLSLLineContinuations; 3689 3690 /** GL_ARB_texture_multisample */ 3691 GLint MaxColorTextureSamples; 3692 GLint MaxDepthTextureSamples; 3693 GLint MaxIntegerSamples; 3694 3695 /** 3696 * GL_EXT_texture_multisample_blit_scaled implementation assumes that 3697 * samples are laid out in a rectangular grid roughly corresponding to 3698 * sample locations within a pixel. Below SampleMap{2,4,8}x variables 3699 * are used to map indices of rectangular grid to sample numbers within 3700 * a pixel. This mapping of indices to sample numbers must be initialized 3701 * by the driver for the target hardware. For example, if we have the 8X 3702 * MSAA sample number layout (sample positions) for XYZ hardware: 3703 * 3704 * sample indices layout sample number layout 3705 * --------- --------- 3706 * | 0 | 1 | | a | b | 3707 * --------- --------- 3708 * | 2 | 3 | | c | d | 3709 * --------- --------- 3710 * | 4 | 5 | | e | f | 3711 * --------- --------- 3712 * | 6 | 7 | | g | h | 3713 * --------- --------- 3714 * 3715 * Where a,b,c,d,e,f,g,h are integers between [0-7]. 3716 * 3717 * Then, initialize the SampleMap8x variable for XYZ hardware as shown 3718 * below: 3719 * SampleMap8x = {a, b, c, d, e, f, g, h}; 3720 * 3721 * Follow the logic for sample counts 2-8. 3722 * 3723 * For 16x the sample indices layout as a 4x4 grid as follows: 3724 * 3725 * ----------------- 3726 * | 0 | 1 | 2 | 3 | 3727 * ----------------- 3728 * | 4 | 5 | 6 | 7 | 3729 * ----------------- 3730 * | 8 | 9 |10 |11 | 3731 * ----------------- 3732 * |12 |13 |14 |15 | 3733 * ----------------- 3734 */ 3735 uint8_t SampleMap2x[2]; 3736 uint8_t SampleMap4x[4]; 3737 uint8_t SampleMap8x[8]; 3738 uint8_t SampleMap16x[16]; 3739 3740 /** GL_ARB_shader_atomic_counters */ 3741 GLuint MaxAtomicBufferBindings; 3742 GLuint MaxAtomicBufferSize; 3743 GLuint MaxCombinedAtomicBuffers; 3744 GLuint MaxCombinedAtomicCounters; 3745 3746 /** GL_ARB_vertex_attrib_binding */ 3747 GLint MaxVertexAttribRelativeOffset; 3748 GLint MaxVertexAttribBindings; 3749 3750 /* GL_ARB_shader_image_load_store */ 3751 GLuint MaxImageUnits; 3752 GLuint MaxCombinedShaderOutputResources; 3753 GLuint MaxImageSamples; 3754 GLuint MaxCombinedImageUniforms; 3755 3756 /** GL_ARB_compute_shader */ 3757 GLuint MaxComputeWorkGroupCount[3]; /* Array of x, y, z dimensions */ 3758 GLuint MaxComputeWorkGroupSize[3]; /* Array of x, y, z dimensions */ 3759 GLuint MaxComputeWorkGroupInvocations; 3760 GLuint MaxComputeSharedMemorySize; 3761 3762 /** GL_ARB_compute_variable_group_size */ 3763 GLuint MaxComputeVariableGroupSize[3]; /* Array of x, y, z dimensions */ 3764 GLuint MaxComputeVariableGroupInvocations; 3765 3766 /** GL_ARB_gpu_shader5 */ 3767 GLfloat MinFragmentInterpolationOffset; 3768 GLfloat MaxFragmentInterpolationOffset; 3769 3770 GLboolean FakeSWMSAA; 3771 3772 /** GL_KHR_context_flush_control */ 3773 GLenum ContextReleaseBehavior; 3774 3775 struct gl_shader_compiler_options ShaderCompilerOptions[MESA_SHADER_STAGES]; 3776 3777 /** GL_ARB_tessellation_shader */ 3778 GLuint MaxPatchVertices; 3779 GLuint MaxTessGenLevel; 3780 GLuint MaxTessPatchComponents; 3781 GLuint MaxTessControlTotalOutputComponents; 3782 bool LowerTessLevel; /**< Lower gl_TessLevel* from float[n] to vecn? */ 3783 bool LowerTCSPatchVerticesIn; /**< Lower gl_PatchVerticesIn to a uniform */ 3784 bool LowerTESPatchVerticesIn; /**< Lower gl_PatchVerticesIn to a uniform */ 3785 bool PrimitiveRestartForPatches; 3786 bool LowerCsDerivedVariables; /**< Lower gl_GlobalInvocationID and 3787 * gl_LocalInvocationIndex based on 3788 * other builtin variables. */ 3789 3790 /** GL_OES_primitive_bounding_box */ 3791 bool NoPrimitiveBoundingBoxOutput; 3792 }; 3793 3794 3795 /** 3796 * Enable flag for each OpenGL extension. Different device drivers will 3797 * enable different extensions at runtime. 3798 */ 3799 struct gl_extensions 3800 { 3801 GLboolean dummy; /* don't remove this! */ 3802 GLboolean dummy_true; /* Set true by _mesa_init_extensions(). */ 3803 GLboolean dummy_false; /* Set false by _mesa_init_extensions(). */ 3804 GLboolean ANGLE_texture_compression_dxt; 3805 GLboolean ARB_ES2_compatibility; 3806 GLboolean ARB_ES3_compatibility; 3807 GLboolean ARB_ES3_1_compatibility; 3808 GLboolean ARB_ES3_2_compatibility; 3809 GLboolean ARB_arrays_of_arrays; 3810 GLboolean ARB_base_instance; 3811 GLboolean ARB_blend_func_extended; 3812 GLboolean ARB_buffer_storage; 3813 GLboolean ARB_clear_texture; 3814 GLboolean ARB_clip_control; 3815 GLboolean ARB_color_buffer_float; 3816 GLboolean ARB_compute_shader; 3817 GLboolean ARB_compute_variable_group_size; 3818 GLboolean ARB_conditional_render_inverted; 3819 GLboolean ARB_conservative_depth; 3820 GLboolean ARB_copy_image; 3821 GLboolean ARB_cull_distance; 3822 GLboolean ARB_depth_buffer_float; 3823 GLboolean ARB_depth_clamp; 3824 GLboolean ARB_depth_texture; 3825 GLboolean ARB_derivative_control; 3826 GLboolean ARB_draw_buffers_blend; 3827 GLboolean ARB_draw_elements_base_vertex; 3828 GLboolean ARB_draw_indirect; 3829 GLboolean ARB_draw_instanced; 3830 GLboolean ARB_fragment_coord_conventions; 3831 GLboolean ARB_fragment_layer_viewport; 3832 GLboolean ARB_fragment_program; 3833 GLboolean ARB_fragment_program_shadow; 3834 GLboolean ARB_fragment_shader; 3835 GLboolean ARB_framebuffer_no_attachments; 3836 GLboolean ARB_framebuffer_object; 3837 GLboolean ARB_enhanced_layouts; 3838 GLboolean ARB_explicit_attrib_location; 3839 GLboolean ARB_explicit_uniform_location; 3840 GLboolean ARB_gpu_shader5; 3841 GLboolean ARB_gpu_shader_fp64; 3842 GLboolean ARB_half_float_vertex; 3843 GLboolean ARB_indirect_parameters; 3844 GLboolean ARB_instanced_arrays; 3845 GLboolean ARB_internalformat_query; 3846 GLboolean ARB_internalformat_query2; 3847 GLboolean ARB_map_buffer_range; 3848 GLboolean ARB_occlusion_query; 3849 GLboolean ARB_occlusion_query2; 3850 GLboolean ARB_pipeline_statistics_query; 3851 GLboolean ARB_point_sprite; 3852 GLboolean ARB_post_depth_coverage; 3853 GLboolean ARB_query_buffer_object; 3854 GLboolean ARB_robust_buffer_access_behavior; 3855 GLboolean ARB_sample_shading; 3856 GLboolean ARB_seamless_cube_map; 3857 GLboolean ARB_shader_atomic_counter_ops; 3858 GLboolean ARB_shader_atomic_counters; 3859 GLboolean ARB_shader_bit_encoding; 3860 GLboolean ARB_shader_clock; 3861 GLboolean ARB_shader_draw_parameters; 3862 GLboolean ARB_shader_group_vote; 3863 GLboolean ARB_shader_image_load_store; 3864 GLboolean ARB_shader_image_size; 3865 GLboolean ARB_shader_precision; 3866 GLboolean ARB_shader_stencil_export; 3867 GLboolean ARB_shader_storage_buffer_object; 3868 GLboolean ARB_shader_subroutine; 3869 GLboolean ARB_shader_texture_image_samples; 3870 GLboolean ARB_shader_texture_lod; 3871 GLboolean ARB_shader_viewport_layer_array; 3872 GLboolean ARB_shading_language_packing; 3873 GLboolean ARB_shading_language_420pack; 3874 GLboolean ARB_shadow; 3875 GLboolean ARB_stencil_texturing; 3876 GLboolean ARB_sync; 3877 GLboolean ARB_tessellation_shader; 3878 GLboolean ARB_texture_border_clamp; 3879 GLboolean ARB_texture_buffer_object; 3880 GLboolean ARB_texture_buffer_object_rgb32; 3881 GLboolean ARB_texture_buffer_range; 3882 GLboolean ARB_texture_compression_bptc; 3883 GLboolean ARB_texture_compression_rgtc; 3884 GLboolean ARB_texture_cube_map; 3885 GLboolean ARB_texture_cube_map_array; 3886 GLboolean ARB_texture_env_combine; 3887 GLboolean ARB_texture_env_crossbar; 3888 GLboolean ARB_texture_env_dot3; 3889 GLboolean ARB_texture_float; 3890 GLboolean ARB_texture_gather; 3891 GLboolean ARB_texture_mirror_clamp_to_edge; 3892 GLboolean ARB_texture_multisample; 3893 GLboolean ARB_texture_non_power_of_two; 3894 GLboolean ARB_texture_stencil8; 3895 GLboolean ARB_texture_query_levels; 3896 GLboolean ARB_texture_query_lod; 3897 GLboolean ARB_texture_rg; 3898 GLboolean ARB_texture_rgb10_a2ui; 3899 GLboolean ARB_texture_view; 3900 GLboolean ARB_timer_query; 3901 GLboolean ARB_transform_feedback2; 3902 GLboolean ARB_transform_feedback3; 3903 GLboolean ARB_transform_feedback_instanced; 3904 GLboolean ARB_uniform_buffer_object; 3905 GLboolean ARB_vertex_attrib_64bit; 3906 GLboolean ARB_vertex_program; 3907 GLboolean ARB_vertex_shader; 3908 GLboolean ARB_vertex_type_10f_11f_11f_rev; 3909 GLboolean ARB_vertex_type_2_10_10_10_rev; 3910 GLboolean ARB_viewport_array; 3911 GLboolean EXT_blend_color; 3912 GLboolean EXT_blend_equation_separate; 3913 GLboolean EXT_blend_func_separate; 3914 GLboolean EXT_blend_minmax; 3915 GLboolean EXT_depth_bounds_test; 3916 GLboolean EXT_draw_buffers2; 3917 GLboolean EXT_framebuffer_multisample; 3918 GLboolean EXT_framebuffer_multisample_blit_scaled; 3919 GLboolean EXT_framebuffer_sRGB; 3920 GLboolean EXT_gpu_program_parameters; 3921 GLboolean EXT_gpu_shader4; 3922 GLboolean EXT_packed_float; 3923 GLboolean EXT_pixel_buffer_object; 3924 GLboolean EXT_point_parameters; 3925 GLboolean EXT_polygon_offset_clamp; 3926 GLboolean EXT_provoking_vertex; 3927 GLboolean EXT_shader_integer_mix; 3928 GLboolean EXT_shader_samples_identical; 3929 GLboolean EXT_stencil_two_side; 3930 GLboolean EXT_texture_array; 3931 GLboolean EXT_texture_compression_latc; 3932 GLboolean EXT_texture_compression_s3tc; 3933 GLboolean EXT_texture_env_dot3; 3934 GLboolean EXT_texture_filter_anisotropic; 3935 GLboolean EXT_texture_integer; 3936 GLboolean EXT_texture_mirror_clamp; 3937 GLboolean EXT_texture_shared_exponent; 3938 GLboolean EXT_texture_snorm; 3939 GLboolean EXT_texture_sRGB; 3940 GLboolean EXT_texture_sRGB_decode; 3941 GLboolean EXT_texture_swizzle; 3942 GLboolean EXT_transform_feedback; 3943 GLboolean EXT_timer_query; 3944 GLboolean EXT_vertex_array_bgra; 3945 GLboolean EXT_window_rectangles; 3946 GLboolean OES_copy_image; 3947 GLboolean OES_primitive_bounding_box; 3948 GLboolean OES_sample_variables; 3949 GLboolean OES_standard_derivatives; 3950 GLboolean OES_texture_buffer; 3951 GLboolean OES_texture_cube_map_array; 3952 GLboolean OES_viewport_array; 3953 /* vendor extensions */ 3954 GLboolean AMD_performance_monitor; 3955 GLboolean AMD_pinned_memory; 3956 GLboolean AMD_seamless_cubemap_per_texture; 3957 GLboolean AMD_vertex_shader_layer; 3958 GLboolean AMD_vertex_shader_viewport_index; 3959 GLboolean ANDROID_extension_pack_es31a; 3960 GLboolean APPLE_object_purgeable; 3961 GLboolean ATI_meminfo; 3962 GLboolean ATI_texture_compression_3dc; 3963 GLboolean ATI_texture_mirror_once; 3964 GLboolean ATI_texture_env_combine3; 3965 GLboolean ATI_fragment_shader; 3966 GLboolean ATI_separate_stencil; 3967 GLboolean GREMEDY_string_marker; 3968 GLboolean INTEL_conservative_rasterization; 3969 GLboolean INTEL_performance_query; 3970 GLboolean KHR_blend_equation_advanced; 3971 GLboolean KHR_blend_equation_advanced_coherent; 3972 GLboolean KHR_robustness; 3973 GLboolean KHR_texture_compression_astc_hdr; 3974 GLboolean KHR_texture_compression_astc_ldr; 3975 GLboolean KHR_texture_compression_astc_sliced_3d; 3976 GLboolean MESA_pack_invert; 3977 GLboolean MESA_shader_framebuffer_fetch; 3978 GLboolean MESA_shader_framebuffer_fetch_non_coherent; 3979 GLboolean MESA_shader_integer_functions; 3980 GLboolean MESA_ycbcr_texture; 3981 GLboolean NV_conditional_render; 3982 GLboolean NV_fog_distance; 3983 GLboolean NV_point_sprite; 3984 GLboolean NV_primitive_restart; 3985 GLboolean NV_texture_barrier; 3986 GLboolean NV_texture_env_combine4; 3987 GLboolean NV_texture_rectangle; 3988 GLboolean NV_vdpau_interop; 3989 GLboolean NVX_gpu_memory_info; 3990 GLboolean TDFX_texture_compression_FXT1; 3991 GLboolean OES_EGL_image; 3992 GLboolean OES_draw_texture; 3993 GLboolean OES_depth_texture_cube_map; 3994 GLboolean OES_EGL_image_external; 3995 GLboolean OES_texture_float; 3996 GLboolean OES_texture_float_linear; 3997 GLboolean OES_texture_half_float; 3998 GLboolean OES_texture_half_float_linear; 3999 GLboolean OES_compressed_ETC1_RGB8_texture; 4000 GLboolean OES_geometry_shader; 4001 GLboolean OES_texture_compression_astc; 4002 GLboolean extension_sentinel; 4003 /** The extension string */ 4004 const GLubyte *String; 4005 /** Number of supported extensions */ 4006 GLuint Count; 4007 /** 4008 * The context version which extension helper functions compare against. 4009 * By default, the value is equal to ctx->Version. This changes to ~0 4010 * while meta is in progress. 4011 */ 4012 GLubyte Version; 4013 }; 4014 4015 4016 /** 4017 * A stack of matrices (projection, modelview, color, texture, etc). 4018 */ 4019 struct gl_matrix_stack 4020 { 4021 GLmatrix *Top; /**< points into Stack */ 4022 GLmatrix *Stack; /**< array [MaxDepth] of GLmatrix */ 4023 unsigned StackSize; /**< Number of elements in Stack */ 4024 GLuint Depth; /**< 0 <= Depth < MaxDepth */ 4025 GLuint MaxDepth; /**< size of Stack[] array */ 4026 GLuint DirtyFlag; /**< _NEW_MODELVIEW or _NEW_PROJECTION, for example */ 4027 }; 4028 4029 4030 /** 4031 * \name Bits for image transfer operations 4032 * \sa __struct gl_contextRec::ImageTransferState. 4033 */ 4034 /*@{*/ 4035 #define IMAGE_SCALE_BIAS_BIT 0x1 4036 #define IMAGE_SHIFT_OFFSET_BIT 0x2 4037 #define IMAGE_MAP_COLOR_BIT 0x4 4038 #define IMAGE_CLAMP_BIT 0x800 4039 4040 4041 /** Pixel Transfer ops */ 4042 #define IMAGE_BITS (IMAGE_SCALE_BIAS_BIT | \ 4043 IMAGE_SHIFT_OFFSET_BIT | \ 4044 IMAGE_MAP_COLOR_BIT) 4045 4046 /** 4047 * \name Bits to indicate what state has changed. 4048 */ 4049 /*@{*/ 4050 #define _NEW_MODELVIEW (1u << 0) /**< gl_context::ModelView */ 4051 #define _NEW_PROJECTION (1u << 1) /**< gl_context::Projection */ 4052 #define _NEW_TEXTURE_MATRIX (1u << 2) /**< gl_context::TextureMatrix */ 4053 #define _NEW_COLOR (1u << 3) /**< gl_context::Color */ 4054 #define _NEW_DEPTH (1u << 4) /**< gl_context::Depth */ 4055 #define _NEW_EVAL (1u << 5) /**< gl_context::Eval, EvalMap */ 4056 #define _NEW_FOG (1u << 6) /**< gl_context::Fog */ 4057 #define _NEW_HINT (1u << 7) /**< gl_context::Hint */ 4058 #define _NEW_LIGHT (1u << 8) /**< gl_context::Light */ 4059 #define _NEW_LINE (1u << 9) /**< gl_context::Line */ 4060 #define _NEW_PIXEL (1u << 10) /**< gl_context::Pixel */ 4061 #define _NEW_POINT (1u << 11) /**< gl_context::Point */ 4062 #define _NEW_POLYGON (1u << 12) /**< gl_context::Polygon */ 4063 #define _NEW_POLYGONSTIPPLE (1u << 13) /**< gl_context::PolygonStipple */ 4064 #define _NEW_SCISSOR (1u << 14) /**< gl_context::Scissor */ 4065 #define _NEW_STENCIL (1u << 15) /**< gl_context::Stencil */ 4066 #define _NEW_TEXTURE (1u << 16) /**< gl_context::Texture */ 4067 #define _NEW_TRANSFORM (1u << 17) /**< gl_context::Transform */ 4068 #define _NEW_VIEWPORT (1u << 18) /**< gl_context::Viewport */ 4069 /* gap, re-use for core Mesa state only; use ctx->DriverFlags otherwise */ 4070 #define _NEW_ARRAY (1u << 20) /**< gl_context::Array */ 4071 #define _NEW_RENDERMODE (1u << 21) /**< gl_context::RenderMode, etc */ 4072 #define _NEW_BUFFERS (1u << 22) /**< gl_context::Visual, DrawBuffer, */ 4073 #define _NEW_CURRENT_ATTRIB (1u << 23) /**< gl_context::Current */ 4074 #define _NEW_MULTISAMPLE (1u << 24) /**< gl_context::Multisample */ 4075 #define _NEW_TRACK_MATRIX (1u << 25) /**< gl_context::VertexProgram */ 4076 #define _NEW_PROGRAM (1u << 26) /**< New program/shader state */ 4077 #define _NEW_PROGRAM_CONSTANTS (1u << 27) 4078 #define _NEW_BUFFER_OBJECT (1u << 28) 4079 #define _NEW_FRAG_CLAMP (1u << 29) 4080 /* gap, re-use for core Mesa state only; use ctx->DriverFlags otherwise */ 4081 #define _NEW_VARYING_VP_INPUTS (1u << 31) /**< gl_context::varying_vp_inputs */ 4082 #define _NEW_ALL ~0 4083 /*@}*/ 4084 4085 4086 /** 4087 * Composite state flags 4088 */ 4089 /*@{*/ 4090 #define _MESA_NEW_NEED_EYE_COORDS (_NEW_LIGHT | \ 4091 _NEW_TEXTURE | \ 4092 _NEW_POINT | \ 4093 _NEW_PROGRAM | \ 4094 _NEW_MODELVIEW) 4095 4096 #define _MESA_NEW_SEPARATE_SPECULAR (_NEW_LIGHT | \ 4097 _NEW_FOG | \ 4098 _NEW_PROGRAM) 4099 4100 4101 /*@}*/ 4102 4103 4104 4105 4106 /* This has to be included here. */ 4107 #include "dd.h" 4108 4109 4110 /** 4111 * Display list flags. 4112 * Strictly this is a tnl-private concept, but it doesn't seem 4113 * worthwhile adding a tnl private structure just to hold this one bit 4114 * of information: 4115 */ 4116 #define DLIST_DANGLING_REFS 0x1 4117 4118 4119 /** Opaque declaration of display list payload data type */ 4120 union gl_dlist_node; 4121 4122 4123 /** 4124 * Provide a location where information about a display list can be 4125 * collected. Could be extended with driverPrivate structures, 4126 * etc. in the future. 4127 */ 4128 struct gl_display_list 4129 { 4130 GLuint Name; 4131 GLchar *Label; /**< GL_KHR_debug */ 4132 GLbitfield Flags; /**< DLIST_x flags */ 4133 /** The dlist commands are in a linked list of nodes */ 4134 union gl_dlist_node *Head; 4135 }; 4136 4137 4138 /** 4139 * State used during display list compilation and execution. 4140 */ 4141 struct gl_dlist_state 4142 { 4143 GLuint CallDepth; /**< Current recursion calling depth */ 4144 4145 struct gl_display_list *CurrentList; /**< List currently being compiled */ 4146 union gl_dlist_node *CurrentBlock; /**< Pointer to current block of nodes */ 4147 GLuint CurrentPos; /**< Index into current block of nodes */ 4148 4149 GLvertexformat ListVtxfmt; 4150 4151 GLubyte ActiveAttribSize[VERT_ATTRIB_MAX]; 4152 GLfloat CurrentAttrib[VERT_ATTRIB_MAX][4]; 4153 4154 GLubyte ActiveMaterialSize[MAT_ATTRIB_MAX]; 4155 GLfloat CurrentMaterial[MAT_ATTRIB_MAX][4]; 4156 4157 struct { 4158 /* State known to have been set by the currently-compiling display 4159 * list. Used to eliminate some redundant state changes. 4160 */ 4161 GLenum ShadeModel; 4162 } Current; 4163 }; 4164 4165 /** @{ 4166 * 4167 * These are a mapping of the GL_ARB_debug_output/GL_KHR_debug enums 4168 * to small enums suitable for use as an array index. 4169 */ 4170 4171 enum mesa_debug_source { 4172 MESA_DEBUG_SOURCE_API, 4173 MESA_DEBUG_SOURCE_WINDOW_SYSTEM, 4174 MESA_DEBUG_SOURCE_SHADER_COMPILER, 4175 MESA_DEBUG_SOURCE_THIRD_PARTY, 4176 MESA_DEBUG_SOURCE_APPLICATION, 4177 MESA_DEBUG_SOURCE_OTHER, 4178 MESA_DEBUG_SOURCE_COUNT 4179 }; 4180 4181 enum mesa_debug_type { 4182 MESA_DEBUG_TYPE_ERROR, 4183 MESA_DEBUG_TYPE_DEPRECATED, 4184 MESA_DEBUG_TYPE_UNDEFINED, 4185 MESA_DEBUG_TYPE_PORTABILITY, 4186 MESA_DEBUG_TYPE_PERFORMANCE, 4187 MESA_DEBUG_TYPE_OTHER, 4188 MESA_DEBUG_TYPE_MARKER, 4189 MESA_DEBUG_TYPE_PUSH_GROUP, 4190 MESA_DEBUG_TYPE_POP_GROUP, 4191 MESA_DEBUG_TYPE_COUNT 4192 }; 4193 4194 enum mesa_debug_severity { 4195 MESA_DEBUG_SEVERITY_LOW, 4196 MESA_DEBUG_SEVERITY_MEDIUM, 4197 MESA_DEBUG_SEVERITY_HIGH, 4198 MESA_DEBUG_SEVERITY_NOTIFICATION, 4199 MESA_DEBUG_SEVERITY_COUNT 4200 }; 4201 4202 /** @} */ 4203 4204 /** 4205 * Driver-specific state flags. 4206 * 4207 * These are or'd with gl_context::NewDriverState to notify a driver about 4208 * a state change. The driver sets the flags at context creation and 4209 * the meaning of the bits set is opaque to core Mesa. 4210 */ 4211 struct gl_driver_flags 4212 { 4213 /** gl_context::Array::_DrawArrays (vertex array state) */ 4214 uint64_t NewArray; 4215 4216 /** gl_context::TransformFeedback::CurrentObject */ 4217 uint64_t NewTransformFeedback; 4218 4219 /** gl_context::TransformFeedback::CurrentObject::shader_program */ 4220 uint64_t NewTransformFeedbackProg; 4221 4222 /** gl_context::RasterDiscard */ 4223 uint64_t NewRasterizerDiscard; 4224 4225 /** 4226 * gl_context::UniformBufferBindings 4227 * gl_shader_program::UniformBlocks 4228 */ 4229 uint64_t NewUniformBuffer; 4230 4231 /** 4232 * gl_context::ShaderStorageBufferBindings 4233 * gl_shader_program::ShaderStorageBlocks 4234 */ 4235 uint64_t NewShaderStorageBuffer; 4236 4237 uint64_t NewTextureBuffer; 4238 4239 /** 4240 * gl_context::AtomicBufferBindings 4241 */ 4242 uint64_t NewAtomicBuffer; 4243 4244 /** 4245 * gl_context::ImageUnits 4246 */ 4247 uint64_t NewImageUnits; 4248 4249 /** 4250 * gl_context::TessCtrlProgram::patch_default_* 4251 */ 4252 uint64_t NewDefaultTessLevels; 4253 4254 /** 4255 * gl_context::IntelConservativeRasterization 4256 */ 4257 uint64_t NewIntelConservativeRasterization; 4258 }; 4259 4260 struct gl_uniform_buffer_binding 4261 { 4262 struct gl_buffer_object *BufferObject; 4263 /** Start of uniform block data in the buffer */ 4264 GLintptr Offset; 4265 /** Size of data allowed to be referenced from the buffer (in bytes) */ 4266 GLsizeiptr Size; 4267 /** 4268 * glBindBufferBase() indicates that the Size should be ignored and only 4269 * limited by the current size of the BufferObject. 4270 */ 4271 GLboolean AutomaticSize; 4272 }; 4273 4274 struct gl_shader_storage_buffer_binding 4275 { 4276 struct gl_buffer_object *BufferObject; 4277 /** Start of shader storage block data in the buffer */ 4278 GLintptr Offset; 4279 /** Size of data allowed to be referenced from the buffer (in bytes) */ 4280 GLsizeiptr Size; 4281 /** 4282 * glBindBufferBase() indicates that the Size should be ignored and only 4283 * limited by the current size of the BufferObject. 4284 */ 4285 GLboolean AutomaticSize; 4286 }; 4287 4288 /** 4289 * ARB_shader_image_load_store image unit. 4290 */ 4291 struct gl_image_unit 4292 { 4293 /** 4294 * Texture object bound to this unit. 4295 */ 4296 struct gl_texture_object *TexObj; 4297 4298 /** 4299 * Level of the texture object bound to this unit. 4300 */ 4301 GLuint Level; 4302 4303 /** 4304 * \c GL_TRUE if the whole level is bound as an array of layers, \c 4305 * GL_FALSE if only some specific layer of the texture is bound. 4306 * \sa Layer 4307 */ 4308 GLboolean Layered; 4309 4310 /** 4311 * Layer of the texture object bound to this unit as specified by the 4312 * application. 4313 */ 4314 GLuint Layer; 4315 4316 /** 4317 * Layer of the texture object bound to this unit, or zero if the 4318 * whole level is bound. 4319 */ 4320 GLuint _Layer; 4321 4322 /** 4323 * Access allowed to this texture image. Either \c GL_READ_ONLY, 4324 * \c GL_WRITE_ONLY or \c GL_READ_WRITE. 4325 */ 4326 GLenum Access; 4327 4328 /** 4329 * GL internal format that determines the interpretation of the 4330 * image memory when shader image operations are performed through 4331 * this unit. 4332 */ 4333 GLenum Format; 4334 4335 /** 4336 * Mesa format corresponding to \c Format. 4337 */ 4338 mesa_format _ActualFormat; 4339 4340 }; 4341 4342 /** 4343 * Binding point for an atomic counter buffer object. 4344 */ 4345 struct gl_atomic_buffer_binding 4346 { 4347 struct gl_buffer_object *BufferObject; 4348 GLintptr Offset; 4349 GLsizeiptr Size; 4350 }; 4351 4352 /** 4353 * Shader subroutines storage 4354 */ 4355 struct gl_subroutine_index_binding 4356 { 4357 GLuint NumIndex; 4358 GLuint *IndexPtr; 4359 }; 4360 4361 /** 4362 * Mesa rendering context. 4363 * 4364 * This is the central context data structure for Mesa. Almost all 4365 * OpenGL state is contained in this structure. 4366 * Think of this as a base class from which device drivers will derive 4367 * sub classes. 4368 */ 4369 struct gl_context 4370 { 4371 /** State possibly shared with other contexts in the address space */ 4372 struct gl_shared_state *Shared; 4373 4374 /** \name API function pointer tables */ 4375 /*@{*/ 4376 gl_api API; 4377 /** 4378 * The current dispatch table for non-displaylist-saving execution, either 4379 * BeginEnd or OutsideBeginEnd 4380 */ 4381 struct _glapi_table *Exec; 4382 /** 4383 * The normal dispatch table for non-displaylist-saving, non-begin/end 4384 */ 4385 struct _glapi_table *OutsideBeginEnd; 4386 /** The dispatch table used between glNewList() and glEndList() */ 4387 struct _glapi_table *Save; 4388 /** 4389 * The dispatch table used between glBegin() and glEnd() (outside of a 4390 * display list). Only valid functions between those two are set, which is 4391 * mostly just the set in a GLvertexformat struct. 4392 */ 4393 struct _glapi_table *BeginEnd; 4394 /** 4395 * Dispatch table for when a graphics reset has happened. 4396 */ 4397 struct _glapi_table *ContextLost; 4398 /** 4399 * Tracks the current dispatch table out of the 4 above, so that it can be 4400 * re-set on glXMakeCurrent(). 4401 */ 4402 struct _glapi_table *CurrentDispatch; 4403 /*@}*/ 4404 4405 struct gl_config Visual; 4406 struct gl_framebuffer *DrawBuffer; /**< buffer for writing */ 4407 struct gl_framebuffer *ReadBuffer; /**< buffer for reading */ 4408 struct gl_framebuffer *WinSysDrawBuffer; /**< set with MakeCurrent */ 4409 struct gl_framebuffer *WinSysReadBuffer; /**< set with MakeCurrent */ 4410 4411 /** 4412 * Device driver function pointer table 4413 */ 4414 struct dd_function_table Driver; 4415 4416 /** Core/Driver constants */ 4417 struct gl_constants Const; 4418 4419 /** \name The various 4x4 matrix stacks */ 4420 /*@{*/ 4421 struct gl_matrix_stack ModelviewMatrixStack; 4422 struct gl_matrix_stack ProjectionMatrixStack; 4423 struct gl_matrix_stack TextureMatrixStack[MAX_TEXTURE_UNITS]; 4424 struct gl_matrix_stack ProgramMatrixStack[MAX_PROGRAM_MATRICES]; 4425 struct gl_matrix_stack *CurrentStack; /**< Points to one of the above stacks */ 4426 /*@}*/ 4427 4428 /** Combined modelview and projection matrix */ 4429 GLmatrix _ModelProjectMatrix; 4430 4431 /** \name Display lists */ 4432 struct gl_dlist_state ListState; 4433 4434 GLboolean ExecuteFlag; /**< Execute GL commands? */ 4435 GLboolean CompileFlag; /**< Compile GL commands into display list? */ 4436 4437 /** Extension information */ 4438 struct gl_extensions Extensions; 4439 4440 /** GL version integer, for example 31 for GL 3.1, or 20 for GLES 2.0. */ 4441 GLuint Version; 4442 char *VersionString; 4443 4444 /** \name State attribute stack (for glPush/PopAttrib) */ 4445 /*@{*/ 4446 GLuint AttribStackDepth; 4447 struct gl_attrib_node *AttribStack[MAX_ATTRIB_STACK_DEPTH]; 4448 /*@}*/ 4449 4450 /** \name Renderer attribute groups 4451 * 4452 * We define a struct for each attribute group to make pushing and popping 4453 * attributes easy. Also it's a good organization. 4454 */ 4455 /*@{*/ 4456 struct gl_accum_attrib Accum; /**< Accum buffer attributes */ 4457 struct gl_colorbuffer_attrib Color; /**< Color buffer attributes */ 4458 struct gl_current_attrib Current; /**< Current attributes */ 4459 struct gl_depthbuffer_attrib Depth; /**< Depth buffer attributes */ 4460 struct gl_eval_attrib Eval; /**< Eval attributes */ 4461 struct gl_fog_attrib Fog; /**< Fog attributes */ 4462 struct gl_hint_attrib Hint; /**< Hint attributes */ 4463 struct gl_light_attrib Light; /**< Light attributes */ 4464 struct gl_line_attrib Line; /**< Line attributes */ 4465 struct gl_list_attrib List; /**< List attributes */ 4466 struct gl_multisample_attrib Multisample; 4467 struct gl_pixel_attrib Pixel; /**< Pixel attributes */ 4468 struct gl_point_attrib Point; /**< Point attributes */ 4469 struct gl_polygon_attrib Polygon; /**< Polygon attributes */ 4470 GLuint PolygonStipple[32]; /**< Polygon stipple */ 4471 struct gl_scissor_attrib Scissor; /**< Scissor attributes */ 4472 struct gl_stencil_attrib Stencil; /**< Stencil buffer attributes */ 4473 struct gl_texture_attrib Texture; /**< Texture attributes */ 4474 struct gl_transform_attrib Transform; /**< Transformation attributes */ 4475 struct gl_viewport_attrib ViewportArray[MAX_VIEWPORTS]; /**< Viewport attributes */ 4476 /*@}*/ 4477 4478 /** \name Client attribute stack */ 4479 /*@{*/ 4480 GLuint ClientAttribStackDepth; 4481 struct gl_attrib_node *ClientAttribStack[MAX_CLIENT_ATTRIB_STACK_DEPTH]; 4482 /*@}*/ 4483 4484 /** \name Client attribute groups */ 4485 /*@{*/ 4486 struct gl_array_attrib Array; /**< Vertex arrays */ 4487 struct gl_pixelstore_attrib Pack; /**< Pixel packing */ 4488 struct gl_pixelstore_attrib Unpack; /**< Pixel unpacking */ 4489 struct gl_pixelstore_attrib DefaultPacking; /**< Default params */ 4490 /*@}*/ 4491 4492 /** \name Other assorted state (not pushed/popped on attribute stack) */ 4493 /*@{*/ 4494 struct gl_pixelmaps PixelMaps; 4495 4496 struct gl_evaluators EvalMap; /**< All evaluators */ 4497 struct gl_feedback Feedback; /**< Feedback */ 4498 struct gl_selection Select; /**< Selection */ 4499 4500 struct gl_program_state Program; /**< general program state */ 4501 struct gl_vertex_program_state VertexProgram; 4502 struct gl_fragment_program_state FragmentProgram; 4503 struct gl_geometry_program_state GeometryProgram; 4504 struct gl_compute_program_state ComputeProgram; 4505 struct gl_tess_ctrl_program_state TessCtrlProgram; 4506 struct gl_tess_eval_program_state TessEvalProgram; 4507 struct gl_ati_fragment_shader_state ATIFragmentShader; 4508 4509 struct gl_pipeline_shader_state Pipeline; /**< GLSL pipeline shader object state */ 4510 struct gl_pipeline_object Shader; /**< GLSL shader object state */ 4511 4512 /** 4513 * Current active shader pipeline state 4514 * 4515 * Almost all internal users want ::_Shader instead of ::Shader. The 4516 * exceptions are bits of legacy GLSL API that do not know about separate 4517 * shader objects. 4518 * 4519 * If a program is active via \c glUseProgram, this will point to 4520 * \c ::Shader. 4521 * 4522 * If a program pipeline is active via \c glBindProgramPipeline, this will 4523 * point to \c ::Pipeline.Current. 4524 * 4525 * If neither a program nor a program pipeline is active, this will point to 4526 * \c ::Pipeline.Default. This ensures that \c ::_Shader will never be 4527 * \c NULL. 4528 */ 4529 struct gl_pipeline_object *_Shader; 4530 4531 struct gl_query_state Query; /**< occlusion, timer queries */ 4532 4533 struct gl_transform_feedback_state TransformFeedback; 4534 4535 struct gl_perf_monitor_state PerfMonitor; 4536 4537 struct gl_buffer_object *DrawIndirectBuffer; /** < GL_ARB_draw_indirect */ 4538 struct gl_buffer_object *ParameterBuffer; /** < GL_ARB_indirect_parameters */ 4539 struct gl_buffer_object *DispatchIndirectBuffer; /** < GL_ARB_compute_shader */ 4540 4541 struct gl_buffer_object *CopyReadBuffer; /**< GL_ARB_copy_buffer */ 4542 struct gl_buffer_object *CopyWriteBuffer; /**< GL_ARB_copy_buffer */ 4543 4544 struct gl_buffer_object *QueryBuffer; /**< GL_ARB_query_buffer_object */ 4545 4546 /** 4547 * Current GL_ARB_uniform_buffer_object binding referenced by 4548 * GL_UNIFORM_BUFFER target for glBufferData, glMapBuffer, etc. 4549 */ 4550 struct gl_buffer_object *UniformBuffer; 4551 4552 /** 4553 * Current GL_ARB_shader_storage_buffer_object binding referenced by 4554 * GL_SHADER_STORAGE_BUFFER target for glBufferData, glMapBuffer, etc. 4555 */ 4556 struct gl_buffer_object *ShaderStorageBuffer; 4557 4558 /** 4559 * Array of uniform buffers for GL_ARB_uniform_buffer_object and GL 3.1. 4560 * This is set up using glBindBufferRange() or glBindBufferBase(). They are 4561 * associated with uniform blocks by glUniformBlockBinding()'s state in the 4562 * shader program. 4563 */ 4564 struct gl_uniform_buffer_binding 4565 UniformBufferBindings[MAX_COMBINED_UNIFORM_BUFFERS]; 4566 4567 /** 4568 * Array of shader storage buffers for ARB_shader_storage_buffer_object 4569 * and GL 4.3. This is set up using glBindBufferRange() or 4570 * glBindBufferBase(). They are associated with shader storage blocks by 4571 * glShaderStorageBlockBinding()'s state in the shader program. 4572 */ 4573 struct gl_shader_storage_buffer_binding 4574 ShaderStorageBufferBindings[MAX_COMBINED_SHADER_STORAGE_BUFFERS]; 4575 4576 /** 4577 * Object currently associated with the GL_ATOMIC_COUNTER_BUFFER 4578 * target. 4579 */ 4580 struct gl_buffer_object *AtomicBuffer; 4581 4582 /** 4583 * Object currently associated w/ the GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD 4584 * target. 4585 */ 4586 struct gl_buffer_object *ExternalVirtualMemoryBuffer; 4587 4588 /** 4589 * Array of atomic counter buffer binding points. 4590 */ 4591 struct gl_atomic_buffer_binding 4592 AtomicBufferBindings[MAX_COMBINED_ATOMIC_BUFFERS]; 4593 4594 /** 4595 * Array of image units for ARB_shader_image_load_store. 4596 */ 4597 struct gl_image_unit ImageUnits[MAX_IMAGE_UNITS]; 4598 4599 struct gl_subroutine_index_binding SubroutineIndex[MESA_SHADER_STAGES]; 4600 /*@}*/ 4601 4602 struct gl_meta_state *Meta; /**< for "meta" operations */ 4603 4604 /* GL_EXT_framebuffer_object */ 4605 struct gl_renderbuffer *CurrentRenderbuffer; 4606 4607 GLenum ErrorValue; /**< Last error code */ 4608 4609 /** 4610 * Recognize and silence repeated error debug messages in buggy apps. 4611 */ 4612 const char *ErrorDebugFmtString; 4613 GLuint ErrorDebugCount; 4614 4615 /* GL_ARB_debug_output/GL_KHR_debug */ 4616 mtx_t DebugMutex; 4617 struct gl_debug_state *Debug; 4618 4619 GLenum RenderMode; /**< either GL_RENDER, GL_SELECT, GL_FEEDBACK */ 4620 GLbitfield NewState; /**< bitwise-or of _NEW_* flags */ 4621 uint64_t NewDriverState; /**< bitwise-or of flags from DriverFlags */ 4622 4623 struct gl_driver_flags DriverFlags; 4624 4625 GLboolean ViewportInitialized; /**< has viewport size been initialized? */ 4626 4627 GLbitfield64 varying_vp_inputs; /**< mask of VERT_BIT_* flags */ 4628 4629 /** \name Derived state */ 4630 GLbitfield _ImageTransferState;/**< bitwise-or of IMAGE_*_BIT flags */ 4631 GLfloat _EyeZDir[3]; 4632 GLfloat _ModelViewInvScale; 4633 GLboolean _NeedEyeCoords; 4634 GLboolean _ForceEyeCoords; 4635 4636 GLuint TextureStateTimestamp; /**< detect changes to shared state */ 4637 4638 struct gl_list_extensions *ListExt; /**< driver dlist extensions */ 4639 4640 /** \name For debugging/development only */ 4641 /*@{*/ 4642 GLboolean FirstTimeCurrent; 4643 /*@}*/ 4644 4645 /** 4646 * False if this context was created without a config. This is needed 4647 * because the initial state of glDrawBuffers depends on this 4648 */ 4649 GLboolean HasConfig; 4650 4651 /** software compression/decompression supported or not */ 4652 GLboolean Mesa_DXTn; 4653 4654 GLboolean TextureFormatSupported[MESA_FORMAT_COUNT]; 4655 4656 GLboolean RasterDiscard; /**< GL_RASTERIZER_DISCARD */ 4657 GLboolean IntelConservativeRasterization; /**< GL_INTEL_CONSERVATIVE_RASTERIZATION */ 4658 4659 /** 4660 * \name Hooks for module contexts. 4661 * 4662 * These will eventually live in the driver or elsewhere. 4663 */ 4664 /*@{*/ 4665 void *swrast_context; 4666 void *swsetup_context; 4667 void *swtnl_context; 4668 struct vbo_context *vbo_context; 4669 struct st_context *st; 4670 void *aelt_context; 4671 /*@}*/ 4672 4673 /** 4674 * \name NV_vdpau_interop 4675 */ 4676 /*@{*/ 4677 const void *vdpDevice; 4678 const void *vdpGetProcAddress; 4679 struct set *vdpSurfaces; 4680 /*@}*/ 4681 4682 /** 4683 * Has this context observed a GPU reset in any context in the share group? 4684 * 4685 * Once this field becomes true, it is never reset to false. 4686 */ 4687 GLboolean ShareGroupReset; 4688 4689 /** 4690 * \name OES_primitive_bounding_box 4691 * 4692 * Stores the arguments to glPrimitiveBoundingBox 4693 */ 4694 GLfloat PrimitiveBoundingBox[8]; 4695 }; 4696 4697 /** 4698 * Information about memory usage. All sizes are in kilobytes. 4699 */ 4700 struct gl_memory_info 4701 { 4702 unsigned total_device_memory; /**< size of device memory, e.g. VRAM */ 4703 unsigned avail_device_memory; /**< free device memory at the moment */ 4704 unsigned total_staging_memory; /**< size of staging memory, e.g. GART */ 4705 unsigned avail_staging_memory; /**< free staging memory at the moment */ 4706 unsigned device_memory_evicted; /**< size of memory evicted (monotonic counter) */ 4707 unsigned nr_device_memory_evictions; /**< # of evictions (monotonic counter) */ 4708 }; 4709 4710 #ifdef DEBUG 4711 extern int MESA_VERBOSE; 4712 extern int MESA_DEBUG_FLAGS; 4713 # define MESA_FUNCTION __func__ 4714 #else 4715 # define MESA_VERBOSE 0 4716 # define MESA_DEBUG_FLAGS 0 4717 # define MESA_FUNCTION "a function" 4718 #endif 4719 4720 4721 /** The MESA_VERBOSE var is a bitmask of these flags */ 4722 enum _verbose 4723 { 4724 VERBOSE_VARRAY = 0x0001, 4725 VERBOSE_TEXTURE = 0x0002, 4726 VERBOSE_MATERIAL = 0x0004, 4727 VERBOSE_PIPELINE = 0x0008, 4728 VERBOSE_DRIVER = 0x0010, 4729 VERBOSE_STATE = 0x0020, 4730 VERBOSE_API = 0x0040, 4731 VERBOSE_DISPLAY_LIST = 0x0100, 4732 VERBOSE_LIGHTING = 0x0200, 4733 VERBOSE_PRIMS = 0x0400, 4734 VERBOSE_VERTS = 0x0800, 4735 VERBOSE_DISASSEM = 0x1000, 4736 VERBOSE_DRAW = 0x2000, 4737 VERBOSE_SWAPBUFFERS = 0x4000 4738 }; 4739 4740 4741 /** The MESA_DEBUG_FLAGS var is a bitmask of these flags */ 4742 enum _debug 4743 { 4744 DEBUG_SILENT = (1 << 0), 4745 DEBUG_ALWAYS_FLUSH = (1 << 1), 4746 DEBUG_INCOMPLETE_TEXTURE = (1 << 2), 4747 DEBUG_INCOMPLETE_FBO = (1 << 3), 4748 DEBUG_CONTEXT = (1 << 4) 4749 }; 4750 4751 #ifdef __cplusplus 4752 } 4753 #endif 4754 4755 #endif /* MTYPES_H */ 4756
