Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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