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