glapi / teximage: implement EGLImageTargetTexStorageEXT
[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/menums.h"
43 #include "main/config.h"
44 #include "glapi/glapi.h"
45 #include "math/m_matrix.h" /* GLmatrix */
46 #include "compiler/shader_enums.h"
47 #include "compiler/shader_info.h"
48 #include "main/formats.h" /* MESA_FORMAT_COUNT */
49 #include "compiler/glsl/list.h"
50 #include "util/simple_mtx.h"
51 #include "util/u_dynarray.h"
52
53
54 #ifdef __cplusplus
55 extern "C" {
56 #endif
57
58 #define GET_COLORMASK_BIT(mask, buf, chan) (((mask) >> (4 * (buf) + (chan))) & 0x1)
59 #define GET_COLORMASK(mask, buf) (((mask) >> (4 * (buf))) & 0xf)
60
61
62 /**
63 * \name Some forward type declarations
64 */
65 /*@{*/
66 struct _mesa_HashTable;
67 struct gl_attrib_node;
68 struct gl_list_extensions;
69 struct gl_meta_state;
70 struct gl_program_cache;
71 struct gl_texture_object;
72 struct gl_debug_state;
73 struct gl_context;
74 struct st_context;
75 struct gl_uniform_storage;
76 struct prog_instruction;
77 struct gl_program_parameter_list;
78 struct gl_shader_spirv_data;
79 struct set;
80 struct shader_includes;
81 struct vbo_context;
82 /*@}*/
83
84
85 /** Extra draw modes beyond GL_POINTS, GL_TRIANGLE_FAN, etc */
86 #define PRIM_MAX GL_PATCHES
87 #define PRIM_OUTSIDE_BEGIN_END (PRIM_MAX + 1)
88 #define PRIM_UNKNOWN (PRIM_MAX + 2)
89
90 /**
91 * Determine if the given gl_varying_slot appears in the fragment shader.
92 */
93 static inline GLboolean
94 _mesa_varying_slot_in_fs(gl_varying_slot slot)
95 {
96 switch (slot) {
97 case VARYING_SLOT_PSIZ:
98 case VARYING_SLOT_BFC0:
99 case VARYING_SLOT_BFC1:
100 case VARYING_SLOT_EDGE:
101 case VARYING_SLOT_CLIP_VERTEX:
102 case VARYING_SLOT_LAYER:
103 case VARYING_SLOT_TESS_LEVEL_OUTER:
104 case VARYING_SLOT_TESS_LEVEL_INNER:
105 case VARYING_SLOT_BOUNDING_BOX0:
106 case VARYING_SLOT_BOUNDING_BOX1:
107 return GL_FALSE;
108 default:
109 return GL_TRUE;
110 }
111 }
112
113 /**
114 * Bit flags for all renderbuffers
115 */
116 #define BUFFER_BIT_FRONT_LEFT (1 << BUFFER_FRONT_LEFT)
117 #define BUFFER_BIT_BACK_LEFT (1 << BUFFER_BACK_LEFT)
118 #define BUFFER_BIT_FRONT_RIGHT (1 << BUFFER_FRONT_RIGHT)
119 #define BUFFER_BIT_BACK_RIGHT (1 << BUFFER_BACK_RIGHT)
120 #define BUFFER_BIT_AUX0 (1 << BUFFER_AUX0)
121 #define BUFFER_BIT_AUX1 (1 << BUFFER_AUX1)
122 #define BUFFER_BIT_AUX2 (1 << BUFFER_AUX2)
123 #define BUFFER_BIT_AUX3 (1 << BUFFER_AUX3)
124 #define BUFFER_BIT_DEPTH (1 << BUFFER_DEPTH)
125 #define BUFFER_BIT_STENCIL (1 << BUFFER_STENCIL)
126 #define BUFFER_BIT_ACCUM (1 << BUFFER_ACCUM)
127 #define BUFFER_BIT_COLOR0 (1 << BUFFER_COLOR0)
128 #define BUFFER_BIT_COLOR1 (1 << BUFFER_COLOR1)
129 #define BUFFER_BIT_COLOR2 (1 << BUFFER_COLOR2)
130 #define BUFFER_BIT_COLOR3 (1 << BUFFER_COLOR3)
131 #define BUFFER_BIT_COLOR4 (1 << BUFFER_COLOR4)
132 #define BUFFER_BIT_COLOR5 (1 << BUFFER_COLOR5)
133 #define BUFFER_BIT_COLOR6 (1 << BUFFER_COLOR6)
134 #define BUFFER_BIT_COLOR7 (1 << BUFFER_COLOR7)
135
136 /**
137 * Mask of all the color buffer bits (but not accum).
138 */
139 #define BUFFER_BITS_COLOR (BUFFER_BIT_FRONT_LEFT | \
140 BUFFER_BIT_BACK_LEFT | \
141 BUFFER_BIT_FRONT_RIGHT | \
142 BUFFER_BIT_BACK_RIGHT | \
143 BUFFER_BIT_AUX0 | \
144 BUFFER_BIT_COLOR0 | \
145 BUFFER_BIT_COLOR1 | \
146 BUFFER_BIT_COLOR2 | \
147 BUFFER_BIT_COLOR3 | \
148 BUFFER_BIT_COLOR4 | \
149 BUFFER_BIT_COLOR5 | \
150 BUFFER_BIT_COLOR6 | \
151 BUFFER_BIT_COLOR7)
152
153 /* Mask of bits for depth+stencil buffers */
154 #define BUFFER_BITS_DEPTH_STENCIL (BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL)
155
156 /**
157 * Framebuffer configuration (aka visual / pixelformat)
158 * Note: some of these fields should be boolean, but it appears that
159 * code in drivers/dri/common/util.c requires int-sized fields.
160 */
161 struct gl_config
162 {
163 GLboolean floatMode;
164 GLuint doubleBufferMode;
165 GLuint stereoMode;
166
167 GLint redBits, greenBits, blueBits, alphaBits; /* bits per comp */
168 GLuint redMask, greenMask, blueMask, alphaMask;
169 GLint redShift, greenShift, blueShift, alphaShift;
170 GLint rgbBits; /* total bits for rgb */
171
172 GLint accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits;
173 GLint depthBits;
174 GLint stencilBits;
175
176 GLint numAuxBuffers;
177
178 GLint level;
179
180 /* EXT_visual_rating / GLX 1.2 */
181 GLint visualRating;
182
183 /* EXT_visual_info / GLX 1.2 */
184 GLint transparentPixel;
185 /* colors are floats scaled to ints */
186 GLint transparentRed, transparentGreen, transparentBlue, transparentAlpha;
187 GLint transparentIndex;
188
189 /* ARB_multisample / SGIS_multisample */
190 GLint sampleBuffers;
191 GLuint samples;
192
193 /* SGIX_pbuffer / GLX 1.3 */
194 GLint maxPbufferWidth;
195 GLint maxPbufferHeight;
196 GLint maxPbufferPixels;
197 GLint optimalPbufferWidth; /* Only for SGIX_pbuffer. */
198 GLint optimalPbufferHeight; /* Only for SGIX_pbuffer. */
199
200 /* OML_swap_method */
201 GLint swapMethod;
202
203 /* EXT_texture_from_pixmap */
204 GLint bindToTextureRgb;
205 GLint bindToTextureRgba;
206 GLint bindToMipmapTexture;
207 GLint bindToTextureTargets;
208 GLint yInverted;
209
210 /* EXT_framebuffer_sRGB */
211 GLint sRGBCapable;
212
213 /* EGL_KHR_mutable_render_buffer */
214 GLuint mutableRenderBuffer; /* bool */
215 };
216
217
218 /**
219 * \name Bit flags used for updating material values.
220 */
221 /*@{*/
222 #define MAT_ATTRIB_FRONT_AMBIENT 0
223 #define MAT_ATTRIB_BACK_AMBIENT 1
224 #define MAT_ATTRIB_FRONT_DIFFUSE 2
225 #define MAT_ATTRIB_BACK_DIFFUSE 3
226 #define MAT_ATTRIB_FRONT_SPECULAR 4
227 #define MAT_ATTRIB_BACK_SPECULAR 5
228 #define MAT_ATTRIB_FRONT_EMISSION 6
229 #define MAT_ATTRIB_BACK_EMISSION 7
230 #define MAT_ATTRIB_FRONT_SHININESS 8
231 #define MAT_ATTRIB_BACK_SHININESS 9
232 #define MAT_ATTRIB_FRONT_INDEXES 10
233 #define MAT_ATTRIB_BACK_INDEXES 11
234 #define MAT_ATTRIB_MAX 12
235
236 #define MAT_ATTRIB_AMBIENT(f) (MAT_ATTRIB_FRONT_AMBIENT+(f))
237 #define MAT_ATTRIB_DIFFUSE(f) (MAT_ATTRIB_FRONT_DIFFUSE+(f))
238 #define MAT_ATTRIB_SPECULAR(f) (MAT_ATTRIB_FRONT_SPECULAR+(f))
239 #define MAT_ATTRIB_EMISSION(f) (MAT_ATTRIB_FRONT_EMISSION+(f))
240 #define MAT_ATTRIB_SHININESS(f)(MAT_ATTRIB_FRONT_SHININESS+(f))
241 #define MAT_ATTRIB_INDEXES(f) (MAT_ATTRIB_FRONT_INDEXES+(f))
242
243 #define MAT_BIT_FRONT_AMBIENT (1<<MAT_ATTRIB_FRONT_AMBIENT)
244 #define MAT_BIT_BACK_AMBIENT (1<<MAT_ATTRIB_BACK_AMBIENT)
245 #define MAT_BIT_FRONT_DIFFUSE (1<<MAT_ATTRIB_FRONT_DIFFUSE)
246 #define MAT_BIT_BACK_DIFFUSE (1<<MAT_ATTRIB_BACK_DIFFUSE)
247 #define MAT_BIT_FRONT_SPECULAR (1<<MAT_ATTRIB_FRONT_SPECULAR)
248 #define MAT_BIT_BACK_SPECULAR (1<<MAT_ATTRIB_BACK_SPECULAR)
249 #define MAT_BIT_FRONT_EMISSION (1<<MAT_ATTRIB_FRONT_EMISSION)
250 #define MAT_BIT_BACK_EMISSION (1<<MAT_ATTRIB_BACK_EMISSION)
251 #define MAT_BIT_FRONT_SHININESS (1<<MAT_ATTRIB_FRONT_SHININESS)
252 #define MAT_BIT_BACK_SHININESS (1<<MAT_ATTRIB_BACK_SHININESS)
253 #define MAT_BIT_FRONT_INDEXES (1<<MAT_ATTRIB_FRONT_INDEXES)
254 #define MAT_BIT_BACK_INDEXES (1<<MAT_ATTRIB_BACK_INDEXES)
255
256
257 #define FRONT_MATERIAL_BITS (MAT_BIT_FRONT_EMISSION | \
258 MAT_BIT_FRONT_AMBIENT | \
259 MAT_BIT_FRONT_DIFFUSE | \
260 MAT_BIT_FRONT_SPECULAR | \
261 MAT_BIT_FRONT_SHININESS | \
262 MAT_BIT_FRONT_INDEXES)
263
264 #define BACK_MATERIAL_BITS (MAT_BIT_BACK_EMISSION | \
265 MAT_BIT_BACK_AMBIENT | \
266 MAT_BIT_BACK_DIFFUSE | \
267 MAT_BIT_BACK_SPECULAR | \
268 MAT_BIT_BACK_SHININESS | \
269 MAT_BIT_BACK_INDEXES)
270
271 #define ALL_MATERIAL_BITS (FRONT_MATERIAL_BITS | BACK_MATERIAL_BITS)
272 /*@}*/
273
274
275 /**
276 * Material state.
277 */
278 struct gl_material
279 {
280 GLfloat Attrib[MAT_ATTRIB_MAX][4];
281 };
282
283
284 /**
285 * Light state flags.
286 */
287 /*@{*/
288 #define LIGHT_SPOT 0x1
289 #define LIGHT_LOCAL_VIEWER 0x2
290 #define LIGHT_POSITIONAL 0x4
291 #define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER)
292 /*@}*/
293
294
295 /**
296 * Light source state.
297 */
298 struct gl_light
299 {
300 GLfloat Ambient[4]; /**< ambient color */
301 GLfloat Diffuse[4]; /**< diffuse color */
302 GLfloat Specular[4]; /**< specular color */
303 GLfloat EyePosition[4]; /**< position in eye coordinates */
304 GLfloat SpotDirection[4]; /**< spotlight direction in eye coordinates */
305 GLfloat SpotExponent;
306 GLfloat SpotCutoff; /**< in degrees */
307 GLfloat _CosCutoff; /**< = MAX(0, cos(SpotCutoff)) */
308 GLfloat ConstantAttenuation;
309 GLfloat LinearAttenuation;
310 GLfloat QuadraticAttenuation;
311 GLboolean Enabled; /**< On/off flag */
312
313 /**
314 * \name Derived fields
315 */
316 /*@{*/
317 GLbitfield _Flags; /**< Mask of LIGHT_x bits defined above */
318
319 GLfloat _Position[4]; /**< position in eye/obj coordinates */
320 GLfloat _VP_inf_norm[3]; /**< Norm direction to infinite light */
321 GLfloat _h_inf_norm[3]; /**< Norm( _VP_inf_norm + <0,0,1> ) */
322 GLfloat _NormSpotDirection[4]; /**< normalized spotlight direction */
323 GLfloat _VP_inf_spot_attenuation;
324
325 GLfloat _MatAmbient[2][3]; /**< material ambient * light ambient */
326 GLfloat _MatDiffuse[2][3]; /**< material diffuse * light diffuse */
327 GLfloat _MatSpecular[2][3]; /**< material spec * light specular */
328 /*@}*/
329 };
330
331
332 /**
333 * Light model state.
334 */
335 struct gl_lightmodel
336 {
337 GLfloat Ambient[4]; /**< ambient color */
338 GLboolean LocalViewer; /**< Local (or infinite) view point? */
339 GLboolean TwoSide; /**< Two (or one) sided lighting? */
340 GLenum16 ColorControl; /**< either GL_SINGLE_COLOR
341 or GL_SEPARATE_SPECULAR_COLOR */
342 };
343
344
345 /**
346 * Accumulation buffer attribute group (GL_ACCUM_BUFFER_BIT)
347 */
348 struct gl_accum_attrib
349 {
350 GLfloat ClearColor[4]; /**< Accumulation buffer clear color */
351 };
352
353
354 /**
355 * Used for storing clear color, texture border color, etc.
356 * The float values are typically unclamped.
357 */
358 union gl_color_union
359 {
360 GLfloat f[4];
361 GLint i[4];
362 GLuint ui[4];
363 };
364
365
366 /**
367 * Color buffer attribute group (GL_COLOR_BUFFER_BIT).
368 */
369 struct gl_colorbuffer_attrib
370 {
371 GLuint ClearIndex; /**< Index for glClear */
372 union gl_color_union ClearColor; /**< Color for glClear, unclamped */
373 GLuint IndexMask; /**< Color index write mask */
374
375 /** 4 colormask bits per draw buffer, max 8 draw buffers. 4*8 = 32 bits */
376 GLbitfield ColorMask;
377
378 GLenum16 DrawBuffer[MAX_DRAW_BUFFERS]; /**< Which buffer to draw into */
379
380 /**
381 * \name alpha testing
382 */
383 /*@{*/
384 GLboolean AlphaEnabled; /**< Alpha test enabled flag */
385 GLenum16 AlphaFunc; /**< Alpha test function */
386 GLfloat AlphaRefUnclamped;
387 GLclampf AlphaRef; /**< Alpha reference value */
388 /*@}*/
389
390 /**
391 * \name Blending
392 */
393 /*@{*/
394 GLbitfield BlendEnabled; /**< Per-buffer blend enable flags */
395
396 /* NOTE: this does _not_ depend on fragment clamping or any other clamping
397 * control, only on the fixed-pointness of the render target.
398 * The query does however depend on fragment color clamping.
399 */
400 GLfloat BlendColorUnclamped[4]; /**< Blending color */
401 GLfloat BlendColor[4]; /**< Blending color */
402
403 struct
404 {
405 GLenum16 SrcRGB; /**< RGB blend source term */
406 GLenum16 DstRGB; /**< RGB blend dest term */
407 GLenum16 SrcA; /**< Alpha blend source term */
408 GLenum16 DstA; /**< Alpha blend dest term */
409 GLenum16 EquationRGB; /**< GL_ADD, GL_SUBTRACT, etc. */
410 GLenum16 EquationA; /**< GL_ADD, GL_SUBTRACT, etc. */
411 /**
412 * Set if any blend factor uses SRC1. Computed at the time blend factors
413 * get set.
414 */
415 GLboolean _UsesDualSrc;
416 } Blend[MAX_DRAW_BUFFERS];
417 /** Are the blend func terms currently different for each buffer/target? */
418 GLboolean _BlendFuncPerBuffer;
419 /** Are the blend equations currently different for each buffer/target? */
420 GLboolean _BlendEquationPerBuffer;
421
422 /**
423 * Which advanced blending mode is in use (or BLEND_NONE).
424 *
425 * KHR_blend_equation_advanced only allows advanced blending with a single
426 * draw buffer, and NVX_blend_equation_advanced_multi_draw_buffer still
427 * requires all draw buffers to match, so we only need a single value.
428 */
429 enum gl_advanced_blend_mode _AdvancedBlendMode;
430
431 /** Coherency requested via glEnable(GL_BLEND_ADVANCED_COHERENT_KHR)? */
432 bool BlendCoherent;
433 /*@}*/
434
435 /**
436 * \name Logic op
437 */
438 /*@{*/
439 GLboolean IndexLogicOpEnabled; /**< Color index logic op enabled flag */
440 GLboolean ColorLogicOpEnabled; /**< RGBA logic op enabled flag */
441 GLenum16 LogicOp; /**< Logic operator */
442 enum gl_logicop_mode _LogicOp;
443 /*@}*/
444
445 GLboolean DitherFlag; /**< Dither enable flag */
446
447 GLboolean _ClampFragmentColor; /** < with GL_FIXED_ONLY_ARB resolved */
448 GLenum16 ClampFragmentColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
449 GLenum16 ClampReadColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
450
451 GLboolean sRGBEnabled; /**< Framebuffer sRGB blending/updating requested */
452 };
453
454
455 /**
456 * Vertex format to describe a vertex element.
457 */
458 struct gl_vertex_format
459 {
460 GLenum16 Type; /**< datatype: GL_FLOAT, GL_INT, etc */
461 GLenum16 Format; /**< default: GL_RGBA, but may be GL_BGRA */
462 GLubyte Size:5; /**< components per element (1,2,3,4) */
463 GLubyte Normalized:1; /**< GL_ARB_vertex_program */
464 GLubyte Integer:1; /**< Integer-valued? */
465 GLubyte Doubles:1; /**< double values are not converted to floats */
466 GLubyte _ElementSize; /**< Size of each element in bytes */
467 };
468
469
470 /**
471 * Current attribute group (GL_CURRENT_BIT).
472 */
473 struct gl_current_attrib
474 {
475 /**
476 * \name Current vertex attributes (color, texcoords, etc).
477 * \note Values are valid only after FLUSH_VERTICES has been called.
478 * \note Index and Edgeflag current values are stored as floats in the
479 * SIX and SEVEN attribute slots.
480 * \note We need double storage for 64-bit vertex attributes
481 */
482 GLfloat Attrib[VERT_ATTRIB_MAX][4*2];
483
484 /**
485 * \name Current raster position attributes (always up to date after a
486 * glRasterPos call).
487 */
488 GLfloat RasterPos[4];
489 GLfloat RasterDistance;
490 GLfloat RasterColor[4];
491 GLfloat RasterSecondaryColor[4];
492 GLfloat RasterTexCoords[MAX_TEXTURE_COORD_UNITS][4];
493 GLboolean RasterPosValid;
494 };
495
496
497 /**
498 * Depth buffer attribute group (GL_DEPTH_BUFFER_BIT).
499 */
500 struct gl_depthbuffer_attrib
501 {
502 GLenum16 Func; /**< Function for depth buffer compare */
503 GLclampd Clear; /**< Value to clear depth buffer to */
504 GLboolean Test; /**< Depth buffering enabled flag */
505 GLboolean Mask; /**< Depth buffer writable? */
506 GLboolean BoundsTest; /**< GL_EXT_depth_bounds_test */
507 GLfloat BoundsMin, BoundsMax;/**< GL_EXT_depth_bounds_test */
508 };
509
510
511 /**
512 * Evaluator attribute group (GL_EVAL_BIT).
513 */
514 struct gl_eval_attrib
515 {
516 /**
517 * \name Enable bits
518 */
519 /*@{*/
520 GLboolean Map1Color4;
521 GLboolean Map1Index;
522 GLboolean Map1Normal;
523 GLboolean Map1TextureCoord1;
524 GLboolean Map1TextureCoord2;
525 GLboolean Map1TextureCoord3;
526 GLboolean Map1TextureCoord4;
527 GLboolean Map1Vertex3;
528 GLboolean Map1Vertex4;
529 GLboolean Map2Color4;
530 GLboolean Map2Index;
531 GLboolean Map2Normal;
532 GLboolean Map2TextureCoord1;
533 GLboolean Map2TextureCoord2;
534 GLboolean Map2TextureCoord3;
535 GLboolean Map2TextureCoord4;
536 GLboolean Map2Vertex3;
537 GLboolean Map2Vertex4;
538 GLboolean AutoNormal;
539 /*@}*/
540
541 /**
542 * \name Map Grid endpoints and divisions and calculated du values
543 */
544 /*@{*/
545 GLint MapGrid1un;
546 GLfloat MapGrid1u1, MapGrid1u2, MapGrid1du;
547 GLint MapGrid2un, MapGrid2vn;
548 GLfloat MapGrid2u1, MapGrid2u2, MapGrid2du;
549 GLfloat MapGrid2v1, MapGrid2v2, MapGrid2dv;
550 /*@}*/
551 };
552
553
554 /**
555 * Compressed fog mode.
556 */
557 enum gl_fog_mode
558 {
559 FOG_NONE,
560 FOG_LINEAR,
561 FOG_EXP,
562 FOG_EXP2,
563 };
564
565
566 /**
567 * Fog attribute group (GL_FOG_BIT).
568 */
569 struct gl_fog_attrib
570 {
571 GLboolean Enabled; /**< Fog enabled flag */
572 GLboolean ColorSumEnabled;
573 uint8_t _PackedMode; /**< Fog mode as 2 bits */
574 uint8_t _PackedEnabledMode; /**< Masked CompressedMode */
575 GLfloat ColorUnclamped[4]; /**< Fog color */
576 GLfloat Color[4]; /**< Fog color */
577 GLfloat Density; /**< Density >= 0.0 */
578 GLfloat Start; /**< Start distance in eye coords */
579 GLfloat End; /**< End distance in eye coords */
580 GLfloat Index; /**< Fog index */
581 GLenum16 Mode; /**< Fog mode */
582 GLenum16 FogCoordinateSource;/**< GL_EXT_fog_coord */
583 GLenum16 FogDistanceMode; /**< GL_NV_fog_distance */
584 };
585
586
587 /**
588 * Hint attribute group (GL_HINT_BIT).
589 *
590 * Values are always one of GL_FASTEST, GL_NICEST, or GL_DONT_CARE.
591 */
592 struct gl_hint_attrib
593 {
594 GLenum16 PerspectiveCorrection;
595 GLenum16 PointSmooth;
596 GLenum16 LineSmooth;
597 GLenum16 PolygonSmooth;
598 GLenum16 Fog;
599 GLenum16 TextureCompression; /**< GL_ARB_texture_compression */
600 GLenum16 GenerateMipmap; /**< GL_SGIS_generate_mipmap */
601 GLenum16 FragmentShaderDerivative; /**< GL_ARB_fragment_shader */
602 GLuint MaxShaderCompilerThreads; /**< GL_ARB_parallel_shader_compile */
603 };
604
605
606 /**
607 * Lighting attribute group (GL_LIGHT_BIT).
608 */
609 struct gl_light_attrib
610 {
611 struct gl_light Light[MAX_LIGHTS]; /**< Array of light sources */
612 struct gl_lightmodel Model; /**< Lighting model */
613
614 /**
615 * Front and back material values.
616 * Note: must call FLUSH_VERTICES() before using.
617 */
618 struct gl_material Material;
619
620 GLboolean Enabled; /**< Lighting enabled flag */
621 GLboolean ColorMaterialEnabled;
622
623 GLenum16 ShadeModel; /**< GL_FLAT or GL_SMOOTH */
624 GLenum16 ProvokingVertex; /**< GL_EXT_provoking_vertex */
625 GLenum16 ColorMaterialFace; /**< GL_FRONT, BACK or FRONT_AND_BACK */
626 GLenum16 ColorMaterialMode; /**< GL_AMBIENT, GL_DIFFUSE, etc */
627 GLbitfield _ColorMaterialBitmask; /**< bitmask formed from Face and Mode */
628
629
630 GLboolean _ClampVertexColor;
631 GLenum16 ClampVertexColor; /**< GL_TRUE, GL_FALSE, GL_FIXED_ONLY */
632
633 /**
634 * Derived state for optimizations:
635 */
636 /*@{*/
637 GLbitfield _EnabledLights; /**< bitmask containing enabled lights */
638
639 GLboolean _NeedEyeCoords;
640 GLboolean _NeedVertices; /**< Use fast shader? */
641
642 GLfloat _BaseColor[2][3];
643 /*@}*/
644 };
645
646
647 /**
648 * Line attribute group (GL_LINE_BIT).
649 */
650 struct gl_line_attrib
651 {
652 GLboolean SmoothFlag; /**< GL_LINE_SMOOTH enabled? */
653 GLboolean StippleFlag; /**< GL_LINE_STIPPLE enabled? */
654 GLushort StipplePattern; /**< Stipple pattern */
655 GLint StippleFactor; /**< Stipple repeat factor */
656 GLfloat Width; /**< Line width */
657 };
658
659
660 /**
661 * Display list attribute group (GL_LIST_BIT).
662 */
663 struct gl_list_attrib
664 {
665 GLuint ListBase;
666 };
667
668
669 /**
670 * Multisample attribute group (GL_MULTISAMPLE_BIT).
671 */
672 struct gl_multisample_attrib
673 {
674 GLboolean Enabled;
675 GLboolean SampleAlphaToCoverage;
676 GLboolean SampleAlphaToOne;
677 GLboolean SampleCoverage;
678 GLboolean SampleCoverageInvert;
679 GLboolean SampleShading;
680
681 /* ARB_texture_multisample / GL3.2 additions */
682 GLboolean SampleMask;
683
684 GLfloat SampleCoverageValue; /**< In range [0, 1] */
685 GLfloat MinSampleShadingValue; /**< In range [0, 1] */
686
687 /** The GL spec defines this as an array but >32x MSAA is madness */
688 GLbitfield SampleMaskValue;
689 };
690
691
692 /**
693 * A pixelmap (see glPixelMap)
694 */
695 struct gl_pixelmap
696 {
697 GLint Size;
698 GLfloat Map[MAX_PIXEL_MAP_TABLE];
699 };
700
701
702 /**
703 * Collection of all pixelmaps
704 */
705 struct gl_pixelmaps
706 {
707 struct gl_pixelmap RtoR; /**< i.e. GL_PIXEL_MAP_R_TO_R */
708 struct gl_pixelmap GtoG;
709 struct gl_pixelmap BtoB;
710 struct gl_pixelmap AtoA;
711 struct gl_pixelmap ItoR;
712 struct gl_pixelmap ItoG;
713 struct gl_pixelmap ItoB;
714 struct gl_pixelmap ItoA;
715 struct gl_pixelmap ItoI;
716 struct gl_pixelmap StoS;
717 };
718
719
720 /**
721 * Pixel attribute group (GL_PIXEL_MODE_BIT).
722 */
723 struct gl_pixel_attrib
724 {
725 GLenum16 ReadBuffer; /**< source buffer for glRead/CopyPixels() */
726
727 /*--- Begin Pixel Transfer State ---*/
728 /* Fields are in the order in which they're applied... */
729
730 /** Scale & Bias (index shift, offset) */
731 /*@{*/
732 GLfloat RedBias, RedScale;
733 GLfloat GreenBias, GreenScale;
734 GLfloat BlueBias, BlueScale;
735 GLfloat AlphaBias, AlphaScale;
736 GLfloat DepthBias, DepthScale;
737 GLint IndexShift, IndexOffset;
738 /*@}*/
739
740 /* Pixel Maps */
741 /* Note: actual pixel maps are not part of this attrib group */
742 GLboolean MapColorFlag;
743 GLboolean MapStencilFlag;
744
745 /*--- End Pixel Transfer State ---*/
746
747 /** glPixelZoom */
748 GLfloat ZoomX, ZoomY;
749 };
750
751
752 /**
753 * Point attribute group (GL_POINT_BIT).
754 */
755 struct gl_point_attrib
756 {
757 GLfloat Size; /**< User-specified point size */
758 GLfloat Params[3]; /**< GL_EXT_point_parameters */
759 GLfloat MinSize, MaxSize; /**< GL_EXT_point_parameters */
760 GLfloat Threshold; /**< GL_EXT_point_parameters */
761 GLboolean SmoothFlag; /**< True if GL_POINT_SMOOTH is enabled */
762 GLboolean _Attenuated; /**< True if Params != [1, 0, 0] */
763 GLboolean PointSprite; /**< GL_NV/ARB_point_sprite */
764 GLbitfield CoordReplace; /**< GL_ARB_point_sprite*/
765 GLenum16 SpriteRMode; /**< GL_NV_point_sprite (only!) */
766 GLenum16 SpriteOrigin; /**< GL_ARB_point_sprite */
767 };
768
769
770 /**
771 * Polygon attribute group (GL_POLYGON_BIT).
772 */
773 struct gl_polygon_attrib
774 {
775 GLenum16 FrontFace; /**< Either GL_CW or GL_CCW */
776 GLenum FrontMode; /**< Either GL_POINT, GL_LINE or GL_FILL */
777 GLenum BackMode; /**< Either GL_POINT, GL_LINE or GL_FILL */
778 GLboolean CullFlag; /**< Culling on/off flag */
779 GLboolean SmoothFlag; /**< True if GL_POLYGON_SMOOTH is enabled */
780 GLboolean StippleFlag; /**< True if GL_POLYGON_STIPPLE is enabled */
781 GLenum16 CullFaceMode; /**< Culling mode GL_FRONT or GL_BACK */
782 GLfloat OffsetFactor; /**< Polygon offset factor, from user */
783 GLfloat OffsetUnits; /**< Polygon offset units, from user */
784 GLfloat OffsetClamp; /**< Polygon offset clamp, from user */
785 GLboolean OffsetPoint; /**< Offset in GL_POINT mode */
786 GLboolean OffsetLine; /**< Offset in GL_LINE mode */
787 GLboolean OffsetFill; /**< Offset in GL_FILL mode */
788 };
789
790
791 /**
792 * Scissor attributes (GL_SCISSOR_BIT).
793 */
794 struct gl_scissor_rect
795 {
796 GLint X, Y; /**< Lower left corner of box */
797 GLsizei Width, Height; /**< Size of box */
798 };
799
800
801 struct gl_scissor_attrib
802 {
803 GLbitfield EnableFlags; /**< Scissor test enabled? */
804 struct gl_scissor_rect ScissorArray[MAX_VIEWPORTS];
805 GLint NumWindowRects; /**< Count of enabled window rectangles */
806 GLenum16 WindowRectMode; /**< Whether to include or exclude the rects */
807 struct gl_scissor_rect WindowRects[MAX_WINDOW_RECTANGLES];
808 };
809
810
811 /**
812 * Stencil attribute group (GL_STENCIL_BUFFER_BIT).
813 *
814 * Three sets of stencil data are tracked so that OpenGL 2.0,
815 * GL_EXT_stencil_two_side, and GL_ATI_separate_stencil can all be supported
816 * simultaneously. In each of the stencil state arrays, element 0 corresponds
817 * to GL_FRONT. Element 1 corresponds to the OpenGL 2.0 /
818 * GL_ATI_separate_stencil GL_BACK state. Element 2 corresponds to the
819 * GL_EXT_stencil_two_side GL_BACK state.
820 *
821 * The derived value \c _BackFace is either 1 or 2 depending on whether or
822 * not GL_STENCIL_TEST_TWO_SIDE_EXT is enabled.
823 *
824 * The derived value \c _TestTwoSide is set when the front-face and back-face
825 * stencil state are different.
826 */
827 struct gl_stencil_attrib
828 {
829 GLboolean Enabled; /**< Enabled flag */
830 GLboolean TestTwoSide; /**< GL_EXT_stencil_two_side */
831 GLubyte ActiveFace; /**< GL_EXT_stencil_two_side (0 or 2) */
832 GLubyte _BackFace; /**< Current back stencil state (1 or 2) */
833 GLenum16 Function[3]; /**< Stencil function */
834 GLenum16 FailFunc[3]; /**< Fail function */
835 GLenum16 ZPassFunc[3]; /**< Depth buffer pass function */
836 GLenum16 ZFailFunc[3]; /**< Depth buffer fail function */
837 GLint Ref[3]; /**< Reference value */
838 GLuint ValueMask[3]; /**< Value mask */
839 GLuint WriteMask[3]; /**< Write mask */
840 GLuint Clear; /**< Clear value */
841 };
842
843
844 /**
845 * Bit flags for each type of texture object
846 */
847 /*@{*/
848 #define TEXTURE_2D_MULTISAMPLE_BIT (1 << TEXTURE_2D_MULTISAMPLE_INDEX)
849 #define TEXTURE_2D_MULTISAMPLE_ARRAY_BIT (1 << TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX)
850 #define TEXTURE_CUBE_ARRAY_BIT (1 << TEXTURE_CUBE_ARRAY_INDEX)
851 #define TEXTURE_BUFFER_BIT (1 << TEXTURE_BUFFER_INDEX)
852 #define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX)
853 #define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX)
854 #define TEXTURE_EXTERNAL_BIT (1 << TEXTURE_EXTERNAL_INDEX)
855 #define TEXTURE_CUBE_BIT (1 << TEXTURE_CUBE_INDEX)
856 #define TEXTURE_3D_BIT (1 << TEXTURE_3D_INDEX)
857 #define TEXTURE_RECT_BIT (1 << TEXTURE_RECT_INDEX)
858 #define TEXTURE_2D_BIT (1 << TEXTURE_2D_INDEX)
859 #define TEXTURE_1D_BIT (1 << TEXTURE_1D_INDEX)
860 /*@}*/
861
862
863 /**
864 * Texture image state. Drivers will typically create a subclass of this
865 * with extra fields for memory buffers, etc.
866 */
867 struct gl_texture_image
868 {
869 GLint InternalFormat; /**< Internal format as given by the user */
870 GLenum16 _BaseFormat; /**< Either GL_RGB, GL_RGBA, GL_ALPHA,
871 * GL_LUMINANCE, GL_LUMINANCE_ALPHA,
872 * GL_INTENSITY, GL_DEPTH_COMPONENT or
873 * GL_DEPTH_STENCIL_EXT only. Used for
874 * choosing TexEnv arithmetic.
875 */
876 mesa_format TexFormat; /**< The actual texture memory format */
877
878 GLuint Border; /**< 0 or 1 */
879 GLuint Width; /**< = 2^WidthLog2 + 2*Border */
880 GLuint Height; /**< = 2^HeightLog2 + 2*Border */
881 GLuint Depth; /**< = 2^DepthLog2 + 2*Border */
882 GLuint Width2; /**< = Width - 2*Border */
883 GLuint Height2; /**< = Height - 2*Border */
884 GLuint Depth2; /**< = Depth - 2*Border */
885 GLuint WidthLog2; /**< = log2(Width2) */
886 GLuint HeightLog2; /**< = log2(Height2) */
887 GLuint DepthLog2; /**< = log2(Depth2) */
888 GLuint MaxNumLevels; /**< = maximum possible number of mipmap
889 levels, computed from the dimensions */
890
891 struct gl_texture_object *TexObject; /**< Pointer back to parent object */
892 GLuint Level; /**< Which mipmap level am I? */
893 /** Cube map face: index into gl_texture_object::Image[] array */
894 GLuint Face;
895
896 /** GL_ARB_texture_multisample */
897 GLuint NumSamples; /**< Sample count, or 0 for non-multisample */
898 GLboolean FixedSampleLocations; /**< Same sample locations for all pixels? */
899 };
900
901
902 /**
903 * Indexes for cube map faces.
904 */
905 typedef enum
906 {
907 FACE_POS_X = 0,
908 FACE_NEG_X = 1,
909 FACE_POS_Y = 2,
910 FACE_NEG_Y = 3,
911 FACE_POS_Z = 4,
912 FACE_NEG_Z = 5,
913 MAX_FACES = 6
914 } gl_face_index;
915
916
917 /**
918 * Sampler object state. These objects are new with GL_ARB_sampler_objects
919 * and OpenGL 3.3. Legacy texture objects also contain a sampler object.
920 */
921 struct gl_sampler_object
922 {
923 simple_mtx_t Mutex;
924 GLuint Name;
925 GLchar *Label; /**< GL_KHR_debug */
926 GLint RefCount;
927
928 GLenum16 WrapS; /**< S-axis texture image wrap mode */
929 GLenum16 WrapT; /**< T-axis texture image wrap mode */
930 GLenum16 WrapR; /**< R-axis texture image wrap mode */
931 GLenum16 MinFilter; /**< minification filter */
932 GLenum16 MagFilter; /**< magnification filter */
933 GLenum16 sRGBDecode; /**< GL_DECODE_EXT or GL_SKIP_DECODE_EXT */
934 union gl_color_union BorderColor; /**< Interpreted according to texture format */
935 GLfloat MinLod; /**< min lambda, OpenGL 1.2 */
936 GLfloat MaxLod; /**< max lambda, OpenGL 1.2 */
937 GLfloat LodBias; /**< OpenGL 1.4 */
938 GLfloat MaxAnisotropy; /**< GL_EXT_texture_filter_anisotropic */
939 GLenum16 CompareMode; /**< GL_ARB_shadow */
940 GLenum16 CompareFunc; /**< GL_ARB_shadow */
941 GLboolean CubeMapSeamless; /**< GL_AMD_seamless_cubemap_per_texture */
942
943 /** GL_ARB_bindless_texture */
944 bool HandleAllocated;
945 struct util_dynarray Handles;
946 };
947
948
949 /**
950 * Texture object state. Contains the array of mipmap images, border color,
951 * wrap modes, filter modes, and shadow/texcompare state.
952 */
953 struct gl_texture_object
954 {
955 simple_mtx_t Mutex; /**< for thread safety */
956 GLint RefCount; /**< reference count */
957 GLuint Name; /**< the user-visible texture object ID */
958 GLenum16 Target; /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */
959 GLenum16 DepthMode; /**< GL_ARB_depth_texture */
960 GLchar *Label; /**< GL_KHR_debug */
961
962 struct gl_sampler_object Sampler;
963
964 gl_texture_index TargetIndex; /**< The gl_texture_unit::CurrentTex index.
965 Only valid when Target is valid. */
966 GLfloat Priority; /**< in [0,1] */
967 GLint MaxLevel; /**< max mipmap level (max=1000), OpenGL 1.2 */
968 GLint BaseLevel; /**< min mipmap level, OpenGL 1.2 */
969 GLbyte _MaxLevel; /**< actual max mipmap level (q in the spec) */
970 GLfloat _MaxLambda; /**< = _MaxLevel - BaseLevel (q - p in spec) */
971 GLint CropRect[4]; /**< GL_OES_draw_texture */
972 GLenum Swizzle[4]; /**< GL_EXT_texture_swizzle */
973 GLushort _Swizzle; /**< same as Swizzle, but SWIZZLE_* format */
974 GLbyte ImmutableLevels; /**< ES 3.0 / ARB_texture_view */
975 GLboolean GenerateMipmap; /**< GL_SGIS_generate_mipmap */
976 GLboolean _BaseComplete; /**< Is the base texture level valid? */
977 GLboolean _MipmapComplete; /**< Is the whole mipmap valid? */
978 GLboolean _IsIntegerFormat; /**< Does the texture store integer values? */
979 GLboolean _RenderToTexture; /**< Any rendering to this texture? */
980 GLboolean Purgeable; /**< Is the buffer purgeable under memory
981 pressure? */
982 GLboolean Immutable; /**< GL_ARB_texture_storage */
983 GLboolean _IsFloat; /**< GL_OES_float_texture */
984 GLboolean _IsHalfFloat; /**< GL_OES_half_float_texture */
985 bool StencilSampling; /**< Should we sample stencil instead of depth? */
986 bool HandleAllocated; /**< GL_ARB_bindless_texture */
987
988 /** GL_OES_EGL_image_external */
989 GLubyte RequiredTextureImageUnits;
990
991 GLubyte MinLevel; /**< GL_ARB_texture_view */
992 GLubyte NumLevels; /**< GL_ARB_texture_view */
993 GLushort MinLayer; /**< GL_ARB_texture_view */
994 GLushort NumLayers; /**< GL_ARB_texture_view */
995
996 /** GL_EXT_memory_object */
997 GLenum16 TextureTiling;
998
999 /** GL_ARB_shader_image_load_store */
1000 GLenum16 ImageFormatCompatibilityType;
1001
1002 /** GL_ARB_texture_buffer_object */
1003 GLenum16 BufferObjectFormat;
1004 /** Equivalent Mesa format for BufferObjectFormat. */
1005 mesa_format _BufferObjectFormat;
1006 struct gl_buffer_object *BufferObject;
1007
1008 /** GL_ARB_texture_buffer_range */
1009 GLintptr BufferOffset;
1010 GLsizeiptr BufferSize; /**< if this is -1, use BufferObject->Size instead */
1011
1012 /** Actual texture images, indexed by [cube face] and [mipmap level] */
1013 struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS];
1014
1015 /** GL_ARB_bindless_texture */
1016 struct util_dynarray SamplerHandles;
1017 struct util_dynarray ImageHandles;
1018 };
1019
1020
1021 /** Up to four combiner sources are possible with GL_NV_texture_env_combine4 */
1022 #define MAX_COMBINER_TERMS 4
1023
1024
1025 /**
1026 * Texture combine environment state.
1027 */
1028 struct gl_tex_env_combine_state
1029 {
1030 GLenum16 ModeRGB; /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
1031 GLenum16 ModeA; /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
1032 /** Source terms: GL_PRIMARY_COLOR, GL_TEXTURE, etc */
1033 GLenum16 SourceRGB[MAX_COMBINER_TERMS];
1034 GLenum16 SourceA[MAX_COMBINER_TERMS];
1035 /** Source operands: GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, etc */
1036 GLenum16 OperandRGB[MAX_COMBINER_TERMS];
1037 GLenum16 OperandA[MAX_COMBINER_TERMS];
1038 GLubyte ScaleShiftRGB; /**< 0, 1 or 2 */
1039 GLubyte ScaleShiftA; /**< 0, 1 or 2 */
1040 GLubyte _NumArgsRGB; /**< Number of inputs used for the RGB combiner */
1041 GLubyte _NumArgsA; /**< Number of inputs used for the A combiner */
1042 };
1043
1044
1045 /** Compressed TexEnv effective Combine mode */
1046 enum gl_tex_env_mode
1047 {
1048 TEXENV_MODE_REPLACE, /* r = a0 */
1049 TEXENV_MODE_MODULATE, /* r = a0 * a1 */
1050 TEXENV_MODE_ADD, /* r = a0 + a1 */
1051 TEXENV_MODE_ADD_SIGNED, /* r = a0 + a1 - 0.5 */
1052 TEXENV_MODE_INTERPOLATE, /* r = a0 * a2 + a1 * (1 - a2) */
1053 TEXENV_MODE_SUBTRACT, /* r = a0 - a1 */
1054 TEXENV_MODE_DOT3_RGB, /* r = a0 . a1 */
1055 TEXENV_MODE_DOT3_RGB_EXT, /* r = a0 . a1 */
1056 TEXENV_MODE_DOT3_RGBA, /* r = a0 . a1 */
1057 TEXENV_MODE_DOT3_RGBA_EXT, /* r = a0 . a1 */
1058 TEXENV_MODE_MODULATE_ADD_ATI, /* r = a0 * a2 + a1 */
1059 TEXENV_MODE_MODULATE_SIGNED_ADD_ATI, /* r = a0 * a2 + a1 - 0.5 */
1060 TEXENV_MODE_MODULATE_SUBTRACT_ATI, /* r = a0 * a2 - a1 */
1061 TEXENV_MODE_ADD_PRODUCTS_NV, /* r = a0 * a1 + a2 * a3 */
1062 TEXENV_MODE_ADD_PRODUCTS_SIGNED_NV, /* r = a0 * a1 + a2 * a3 - 0.5 */
1063 };
1064
1065
1066 /** Compressed TexEnv Combine source */
1067 enum gl_tex_env_source
1068 {
1069 TEXENV_SRC_TEXTURE0,
1070 TEXENV_SRC_TEXTURE1,
1071 TEXENV_SRC_TEXTURE2,
1072 TEXENV_SRC_TEXTURE3,
1073 TEXENV_SRC_TEXTURE4,
1074 TEXENV_SRC_TEXTURE5,
1075 TEXENV_SRC_TEXTURE6,
1076 TEXENV_SRC_TEXTURE7,
1077 TEXENV_SRC_TEXTURE,
1078 TEXENV_SRC_PREVIOUS,
1079 TEXENV_SRC_PRIMARY_COLOR,
1080 TEXENV_SRC_CONSTANT,
1081 TEXENV_SRC_ZERO,
1082 TEXENV_SRC_ONE,
1083 };
1084
1085
1086 /** Compressed TexEnv Combine operand */
1087 enum gl_tex_env_operand
1088 {
1089 TEXENV_OPR_COLOR,
1090 TEXENV_OPR_ONE_MINUS_COLOR,
1091 TEXENV_OPR_ALPHA,
1092 TEXENV_OPR_ONE_MINUS_ALPHA,
1093 };
1094
1095
1096 /** Compressed TexEnv Combine argument */
1097 struct gl_tex_env_argument
1098 {
1099 #ifdef __GNUC__
1100 __extension__ uint8_t Source:4; /**< TEXENV_SRC_x */
1101 __extension__ uint8_t Operand:2; /**< TEXENV_OPR_x */
1102 #else
1103 uint8_t Source; /**< SRC_x */
1104 uint8_t Operand; /**< OPR_x */
1105 #endif
1106 };
1107
1108
1109 /***
1110 * Compressed TexEnv Combine state.
1111 */
1112 struct gl_tex_env_combine_packed
1113 {
1114 uint32_t ModeRGB:4; /**< Effective mode for RGB as 4 bits */
1115 uint32_t ModeA:4; /**< Effective mode for RGB as 4 bits */
1116 uint32_t ScaleShiftRGB:2; /**< 0, 1 or 2 */
1117 uint32_t ScaleShiftA:2; /**< 0, 1 or 2 */
1118 uint32_t NumArgsRGB:3; /**< Number of inputs used for the RGB combiner */
1119 uint32_t NumArgsA:3; /**< Number of inputs used for the A combiner */
1120 /** Source arguments in a packed manner */
1121 struct gl_tex_env_argument ArgsRGB[MAX_COMBINER_TERMS];
1122 struct gl_tex_env_argument ArgsA[MAX_COMBINER_TERMS];
1123 };
1124
1125
1126 /**
1127 * TexGenEnabled flags.
1128 */
1129 /*@{*/
1130 #define S_BIT 1
1131 #define T_BIT 2
1132 #define R_BIT 4
1133 #define Q_BIT 8
1134 #define STR_BITS (S_BIT | T_BIT | R_BIT)
1135 /*@}*/
1136
1137
1138 /**
1139 * Bit flag versions of the corresponding GL_ constants.
1140 */
1141 /*@{*/
1142 #define TEXGEN_SPHERE_MAP 0x1
1143 #define TEXGEN_OBJ_LINEAR 0x2
1144 #define TEXGEN_EYE_LINEAR 0x4
1145 #define TEXGEN_REFLECTION_MAP_NV 0x8
1146 #define TEXGEN_NORMAL_MAP_NV 0x10
1147
1148 #define TEXGEN_NEED_NORMALS (TEXGEN_SPHERE_MAP | \
1149 TEXGEN_REFLECTION_MAP_NV | \
1150 TEXGEN_NORMAL_MAP_NV)
1151 #define TEXGEN_NEED_EYE_COORD (TEXGEN_SPHERE_MAP | \
1152 TEXGEN_REFLECTION_MAP_NV | \
1153 TEXGEN_NORMAL_MAP_NV | \
1154 TEXGEN_EYE_LINEAR)
1155 /*@}*/
1156
1157
1158
1159 /** Tex-gen enabled for texture unit? */
1160 #define ENABLE_TEXGEN(unit) (1 << (unit))
1161
1162 /** Non-identity texture matrix for texture unit? */
1163 #define ENABLE_TEXMAT(unit) (1 << (unit))
1164
1165
1166 /**
1167 * Texture coord generation state.
1168 */
1169 struct gl_texgen
1170 {
1171 GLenum16 Mode; /**< GL_EYE_LINEAR, GL_SPHERE_MAP, etc */
1172 GLbitfield8 _ModeBit; /**< TEXGEN_x bit corresponding to Mode */
1173 GLfloat ObjectPlane[4];
1174 GLfloat EyePlane[4];
1175 };
1176
1177
1178 /**
1179 * Sampler-related subset of a texture unit, like current texture objects.
1180 */
1181 struct gl_texture_unit
1182 {
1183 GLfloat LodBias; /**< for biasing mipmap levels */
1184
1185 /** Texture targets that have a non-default texture bound */
1186 GLbitfield _BoundTextures;
1187
1188 /** Current sampler object (GL_ARB_sampler_objects) */
1189 struct gl_sampler_object *Sampler;
1190
1191 /** Current texture object pointers */
1192 struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS];
1193
1194 /** Points to highest priority, complete and enabled texture object */
1195 struct gl_texture_object *_Current;
1196 };
1197
1198
1199 /**
1200 * Fixed-function-related subset of a texture unit, like enable flags,
1201 * texture environment/function/combiners, and texgen state.
1202 */
1203 struct gl_fixedfunc_texture_unit
1204 {
1205 GLbitfield16 Enabled; /**< bitmask of TEXTURE_*_BIT flags */
1206
1207 GLenum16 EnvMode; /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */
1208 GLclampf EnvColor[4];
1209 GLfloat EnvColorUnclamped[4];
1210
1211 struct gl_texgen GenS;
1212 struct gl_texgen GenT;
1213 struct gl_texgen GenR;
1214 struct gl_texgen GenQ;
1215 GLbitfield8 TexGenEnabled; /**< Bitwise-OR of [STRQ]_BIT values */
1216 GLbitfield8 _GenFlags; /**< Bitwise-OR of Gen[STRQ]._ModeBit */
1217
1218 /**
1219 * \name GL_EXT_texture_env_combine
1220 */
1221 struct gl_tex_env_combine_state Combine;
1222
1223 /**
1224 * Derived state based on \c EnvMode and the \c BaseFormat of the
1225 * currently enabled texture.
1226 */
1227 struct gl_tex_env_combine_state _EnvMode;
1228
1229 /** Current compressed TexEnv & Combine state */
1230 struct gl_tex_env_combine_packed _CurrentCombinePacked;
1231
1232 /**
1233 * Currently enabled combiner state. This will point to either
1234 * \c Combine or \c _EnvMode.
1235 */
1236 struct gl_tex_env_combine_state *_CurrentCombine;
1237 };
1238
1239
1240 /**
1241 * Texture attribute group (GL_TEXTURE_BIT).
1242 */
1243 struct gl_texture_attrib
1244 {
1245 struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS];
1246
1247 /** GL_ARB_texture_buffer_object */
1248 struct gl_buffer_object *BufferObject;
1249
1250 GLuint CurrentUnit; /**< GL_ACTIVE_TEXTURE */
1251
1252 /** Texture coord units/sets used for fragment texturing */
1253 GLbitfield8 _EnabledCoordUnits;
1254
1255 /** Texture coord units that have texgen enabled */
1256 GLbitfield8 _TexGenEnabled;
1257
1258 /** Texture coord units that have non-identity matrices */
1259 GLbitfield8 _TexMatEnabled;
1260
1261 /** Bitwise-OR of all Texture.Unit[i]._GenFlags */
1262 GLbitfield8 _GenFlags;
1263
1264 /** Largest index of a texture unit with _Current != NULL. */
1265 GLshort _MaxEnabledTexImageUnit;
1266
1267 /** Largest index + 1 of texture units that have had any CurrentTex set. */
1268 GLubyte NumCurrentTexUsed;
1269
1270 /** GL_ARB_seamless_cubemap */
1271 GLboolean CubeMapSeamless;
1272
1273 struct gl_texture_unit Unit[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
1274 struct gl_fixedfunc_texture_unit FixedFuncUnit[MAX_TEXTURE_COORD_UNITS];
1275 };
1276
1277
1278 /**
1279 * Data structure representing a single clip plane (e.g. one of the elements
1280 * of the ctx->Transform.EyeUserPlane or ctx->Transform._ClipUserPlane array).
1281 */
1282 typedef GLfloat gl_clip_plane[4];
1283
1284
1285 /**
1286 * Transformation attribute group (GL_TRANSFORM_BIT).
1287 */
1288 struct gl_transform_attrib
1289 {
1290 GLenum16 MatrixMode; /**< Matrix mode */
1291 gl_clip_plane EyeUserPlane[MAX_CLIP_PLANES]; /**< User clip planes */
1292 gl_clip_plane _ClipUserPlane[MAX_CLIP_PLANES]; /**< derived */
1293 GLbitfield ClipPlanesEnabled; /**< on/off bitmask */
1294 GLboolean Normalize; /**< Normalize all normals? */
1295 GLboolean RescaleNormals; /**< GL_EXT_rescale_normal */
1296 GLboolean RasterPositionUnclipped; /**< GL_IBM_rasterpos_clip */
1297 GLboolean DepthClampNear; /**< GL_AMD_depth_clamp_separate */
1298 GLboolean DepthClampFar; /**< GL_AMD_depth_clamp_separate */
1299 /** GL_ARB_clip_control */
1300 GLenum16 ClipOrigin; /**< GL_LOWER_LEFT or GL_UPPER_LEFT */
1301 GLenum16 ClipDepthMode;/**< GL_NEGATIVE_ONE_TO_ONE or GL_ZERO_TO_ONE */
1302 };
1303
1304
1305 /**
1306 * Viewport attribute group (GL_VIEWPORT_BIT).
1307 */
1308 struct gl_viewport_attrib
1309 {
1310 GLfloat X, Y; /**< position */
1311 GLfloat Width, Height; /**< size */
1312 GLfloat Near, Far; /**< Depth buffer range */
1313 };
1314
1315
1316 /**
1317 * Fields describing a mapped buffer range.
1318 */
1319 struct gl_buffer_mapping
1320 {
1321 GLbitfield AccessFlags; /**< Mask of GL_MAP_x_BIT flags */
1322 GLvoid *Pointer; /**< User-space address of mapping */
1323 GLintptr Offset; /**< Mapped offset */
1324 GLsizeiptr Length; /**< Mapped length */
1325 };
1326
1327
1328 /**
1329 * Usages we've seen for a buffer object.
1330 */
1331 typedef enum
1332 {
1333 USAGE_UNIFORM_BUFFER = 0x1,
1334 USAGE_TEXTURE_BUFFER = 0x2,
1335 USAGE_ATOMIC_COUNTER_BUFFER = 0x4,
1336 USAGE_SHADER_STORAGE_BUFFER = 0x8,
1337 USAGE_TRANSFORM_FEEDBACK_BUFFER = 0x10,
1338 USAGE_PIXEL_PACK_BUFFER = 0x20,
1339 USAGE_ARRAY_BUFFER = 0x40,
1340 USAGE_ELEMENT_ARRAY_BUFFER = 0x80,
1341 USAGE_DISABLE_MINMAX_CACHE = 0x100,
1342 } gl_buffer_usage;
1343
1344
1345 /**
1346 * GL_ARB_vertex/pixel_buffer_object buffer object
1347 */
1348 struct gl_buffer_object
1349 {
1350 GLint RefCount;
1351 GLuint Name;
1352 GLchar *Label; /**< GL_KHR_debug */
1353 GLenum16 Usage; /**< GL_STREAM_DRAW_ARB, GL_STREAM_READ_ARB, etc. */
1354 GLbitfield StorageFlags; /**< GL_MAP_PERSISTENT_BIT, etc. */
1355 GLsizeiptrARB Size; /**< Size of buffer storage in bytes */
1356 GLubyte *Data; /**< Location of storage either in RAM or VRAM. */
1357 GLboolean DeletePending; /**< true if buffer object is removed from the hash */
1358 GLboolean Written; /**< Ever written to? (for debugging) */
1359 GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */
1360 GLboolean Immutable; /**< GL_ARB_buffer_storage */
1361 gl_buffer_usage UsageHistory; /**< How has this buffer been used so far? */
1362
1363 /** Counters used for buffer usage warnings */
1364 GLuint NumSubDataCalls;
1365 GLuint NumMapBufferWriteCalls;
1366
1367 struct gl_buffer_mapping Mappings[MAP_COUNT];
1368
1369 /** Memoization of min/max index computations for static index buffers */
1370 simple_mtx_t MinMaxCacheMutex;
1371 struct hash_table *MinMaxCache;
1372 unsigned MinMaxCacheHitIndices;
1373 unsigned MinMaxCacheMissIndices;
1374 bool MinMaxCacheDirty;
1375
1376 bool HandleAllocated; /**< GL_ARB_bindless_texture */
1377 };
1378
1379
1380 /**
1381 * Client pixel packing/unpacking attributes
1382 */
1383 struct gl_pixelstore_attrib
1384 {
1385 GLint Alignment;
1386 GLint RowLength;
1387 GLint SkipPixels;
1388 GLint SkipRows;
1389 GLint ImageHeight;
1390 GLint SkipImages;
1391 GLboolean SwapBytes;
1392 GLboolean LsbFirst;
1393 GLboolean Invert; /**< GL_MESA_pack_invert */
1394 GLint CompressedBlockWidth; /**< GL_ARB_compressed_texture_pixel_storage */
1395 GLint CompressedBlockHeight;
1396 GLint CompressedBlockDepth;
1397 GLint CompressedBlockSize;
1398 struct gl_buffer_object *BufferObj; /**< GL_ARB_pixel_buffer_object */
1399 };
1400
1401
1402 /**
1403 * Enum for defining the mapping for the position/generic0 attribute.
1404 *
1405 * Do not change the order of the values as these are used as
1406 * array indices.
1407 */
1408 typedef enum
1409 {
1410 ATTRIBUTE_MAP_MODE_IDENTITY, /**< 1:1 mapping */
1411 ATTRIBUTE_MAP_MODE_POSITION, /**< get position and generic0 from position */
1412 ATTRIBUTE_MAP_MODE_GENERIC0, /**< get position and generic0 from generic0 */
1413 ATTRIBUTE_MAP_MODE_MAX /**< for sizing arrays */
1414 } gl_attribute_map_mode;
1415
1416
1417 /**
1418 * Attributes to describe a vertex array.
1419 *
1420 * Contains the size, type, format and normalization flag,
1421 * along with the index of a vertex buffer binding point.
1422 *
1423 * Note that the Stride field corresponds to VERTEX_ATTRIB_ARRAY_STRIDE
1424 * and is only present for backwards compatibility reasons.
1425 * Rendering always uses VERTEX_BINDING_STRIDE.
1426 * The gl*Pointer() functions will set VERTEX_ATTRIB_ARRAY_STRIDE
1427 * and VERTEX_BINDING_STRIDE to the same value, while
1428 * glBindVertexBuffer() will only set VERTEX_BINDING_STRIDE.
1429 */
1430 struct gl_array_attributes
1431 {
1432 /** Points to client array data. Not used when a VBO is bound */
1433 const GLubyte *Ptr;
1434 /** Offset of the first element relative to the binding offset */
1435 GLuint RelativeOffset;
1436 /** Vertex format */
1437 struct gl_vertex_format Format;
1438 /** Stride as specified with gl*Pointer() */
1439 GLshort Stride;
1440 /** Index into gl_vertex_array_object::BufferBinding[] array */
1441 GLubyte BufferBindingIndex;
1442
1443 /**
1444 * Derived effective buffer binding index
1445 *
1446 * Index into the gl_vertex_buffer_binding array of the vao.
1447 * Similar to BufferBindingIndex, but with the mapping of the
1448 * position/generic0 attributes applied and with identical
1449 * gl_vertex_buffer_binding entries collapsed to a single
1450 * entry within the vao.
1451 *
1452 * The value is valid past calling _mesa_update_vao_derived_arrays.
1453 * Note that _mesa_update_vao_derived_arrays is called when binding
1454 * the VAO to Array._DrawVAO.
1455 */
1456 GLubyte _EffBufferBindingIndex;
1457 /**
1458 * Derived effective relative offset.
1459 *
1460 * Relative offset to the effective buffers offset in
1461 * gl_vertex_buffer_binding::_EffOffset.
1462 *
1463 * The value is valid past calling _mesa_update_vao_derived_arrays.
1464 * Note that _mesa_update_vao_derived_arrays is called when binding
1465 * the VAO to Array._DrawVAO.
1466 */
1467 GLushort _EffRelativeOffset;
1468 };
1469
1470
1471 /**
1472 * This describes the buffer object used for a vertex array (or
1473 * multiple vertex arrays). If BufferObj points to the default/null
1474 * buffer object, then the vertex array lives in user memory and not a VBO.
1475 */
1476 struct gl_vertex_buffer_binding
1477 {
1478 GLintptr Offset; /**< User-specified offset */
1479 GLsizei Stride; /**< User-specified stride */
1480 GLuint InstanceDivisor; /**< GL_ARB_instanced_arrays */
1481 struct gl_buffer_object *BufferObj; /**< GL_ARB_vertex_buffer_object */
1482 GLbitfield _BoundArrays; /**< Arrays bound to this binding point */
1483
1484 /**
1485 * Derived effective bound arrays.
1486 *
1487 * The effective binding handles enabled arrays past the
1488 * position/generic0 attribute mapping and reduces the refered
1489 * gl_vertex_buffer_binding entries to a unique subset.
1490 *
1491 * The value is valid past calling _mesa_update_vao_derived_arrays.
1492 * Note that _mesa_update_vao_derived_arrays is called when binding
1493 * the VAO to Array._DrawVAO.
1494 */
1495 GLbitfield _EffBoundArrays;
1496 /**
1497 * Derived offset.
1498 *
1499 * The absolute offset to that we can collapse some attributes
1500 * to this unique effective binding.
1501 * For user space array bindings this contains the smallest pointer value
1502 * in the bound and interleaved arrays.
1503 * For VBO bindings this contains an offset that lets the attributes
1504 * _EffRelativeOffset stay positive and in bounds with
1505 * Const.MaxVertexAttribRelativeOffset
1506 *
1507 * The value is valid past calling _mesa_update_vao_derived_arrays.
1508 * Note that _mesa_update_vao_derived_arrays is called when binding
1509 * the VAO to Array._DrawVAO.
1510 */
1511 GLintptr _EffOffset;
1512 };
1513
1514
1515 /**
1516 * A representation of "Vertex Array Objects" (VAOs) from OpenGL 3.1+ /
1517 * the GL_ARB_vertex_array_object extension.
1518 */
1519 struct gl_vertex_array_object
1520 {
1521 /** Name of the VAO as received from glGenVertexArray. */
1522 GLuint Name;
1523
1524 GLint RefCount;
1525
1526 GLchar *Label; /**< GL_KHR_debug */
1527
1528 /**
1529 * Has this array object been bound?
1530 */
1531 GLboolean EverBound;
1532
1533 /**
1534 * Marked to true if the object is shared between contexts and immutable.
1535 * Then reference counting is done using atomics and thread safe.
1536 * Is used for dlist VAOs.
1537 */
1538 bool SharedAndImmutable;
1539
1540 /** Vertex attribute arrays */
1541 struct gl_array_attributes VertexAttrib[VERT_ATTRIB_MAX];
1542
1543 /** Vertex buffer bindings */
1544 struct gl_vertex_buffer_binding BufferBinding[VERT_ATTRIB_MAX];
1545
1546 /** Mask indicating which vertex arrays have vertex buffer associated. */
1547 GLbitfield VertexAttribBufferMask;
1548
1549 /** Mask of VERT_BIT_* values indicating which arrays are enabled */
1550 GLbitfield Enabled;
1551
1552 /**
1553 * Mask of VERT_BIT_* enabled arrays past position/generic0 mapping
1554 *
1555 * The value is valid past calling _mesa_update_vao_derived_arrays.
1556 * Note that _mesa_update_vao_derived_arrays is called when binding
1557 * the VAO to Array._DrawVAO.
1558 */
1559 GLbitfield _EffEnabledVBO;
1560
1561 /** Denotes the way the position/generic0 attribute is mapped */
1562 gl_attribute_map_mode _AttributeMapMode;
1563
1564 /** Mask of VERT_BIT_* values indicating changed/dirty arrays */
1565 GLbitfield NewArrays;
1566
1567 /** The index buffer (also known as the element array buffer in OpenGL). */
1568 struct gl_buffer_object *IndexBufferObj;
1569 };
1570
1571
1572 /**
1573 * Vertex array state
1574 */
1575 struct gl_array_attrib
1576 {
1577 /** Currently bound array object. */
1578 struct gl_vertex_array_object *VAO;
1579
1580 /** The default vertex array object */
1581 struct gl_vertex_array_object *DefaultVAO;
1582
1583 /** The last VAO accessed by a DSA function */
1584 struct gl_vertex_array_object *LastLookedUpVAO;
1585
1586 /** Array objects (GL_ARB_vertex_array_object) */
1587 struct _mesa_HashTable *Objects;
1588
1589 GLint ActiveTexture; /**< Client Active Texture */
1590 GLuint LockFirst; /**< GL_EXT_compiled_vertex_array */
1591 GLuint LockCount; /**< GL_EXT_compiled_vertex_array */
1592
1593 /**
1594 * \name Primitive restart controls
1595 *
1596 * Primitive restart is enabled if either \c PrimitiveRestart or
1597 * \c PrimitiveRestartFixedIndex is set.
1598 */
1599 /*@{*/
1600 GLboolean PrimitiveRestart;
1601 GLboolean PrimitiveRestartFixedIndex;
1602 GLboolean _PrimitiveRestart;
1603 GLuint RestartIndex;
1604 /*@}*/
1605
1606 /* GL_ARB_vertex_buffer_object */
1607 struct gl_buffer_object *ArrayBufferObj;
1608
1609 /**
1610 * Vertex array object that is used with the currently active draw command.
1611 * The _DrawVAO is either set to the currently bound VAO for array type
1612 * draws or to internal VAO's set up by the vbo module to execute immediate
1613 * mode or display list draws.
1614 */
1615 struct gl_vertex_array_object *_DrawVAO;
1616 /**
1617 * The VERT_BIT_* bits effectively enabled from the current _DrawVAO.
1618 * This is always a subset of _mesa_get_vao_vp_inputs(_DrawVAO)
1619 * but may omit those arrays that shall not be referenced by the current
1620 * gl_vertex_program_state::_VPMode. For example the generic attributes are
1621 * maked out form the _DrawVAO's enabled arrays when a fixed function
1622 * array draw is executed.
1623 */
1624 GLbitfield _DrawVAOEnabledAttribs;
1625 /**
1626 * Initially or if the VAO referenced by _DrawVAO is deleted the _DrawVAO
1627 * pointer is set to the _EmptyVAO which is just an empty VAO all the time.
1628 */
1629 struct gl_vertex_array_object *_EmptyVAO;
1630
1631 /** Legal array datatypes and the API for which they have been computed */
1632 GLbitfield LegalTypesMask;
1633 gl_api LegalTypesMaskAPI;
1634 };
1635
1636
1637 /**
1638 * Feedback buffer state
1639 */
1640 struct gl_feedback
1641 {
1642 GLenum16 Type;
1643 GLbitfield _Mask; /**< FB_* bits */
1644 GLfloat *Buffer;
1645 GLuint BufferSize;
1646 GLuint Count;
1647 };
1648
1649
1650 /**
1651 * Selection buffer state
1652 */
1653 struct gl_selection
1654 {
1655 GLuint *Buffer; /**< selection buffer */
1656 GLuint BufferSize; /**< size of the selection buffer */
1657 GLuint BufferCount; /**< number of values in the selection buffer */
1658 GLuint Hits; /**< number of records in the selection buffer */
1659 GLuint NameStackDepth; /**< name stack depth */
1660 GLuint NameStack[MAX_NAME_STACK_DEPTH]; /**< name stack */
1661 GLboolean HitFlag; /**< hit flag */
1662 GLfloat HitMinZ; /**< minimum hit depth */
1663 GLfloat HitMaxZ; /**< maximum hit depth */
1664 };
1665
1666
1667 /**
1668 * 1-D Evaluator control points
1669 */
1670 struct gl_1d_map
1671 {
1672 GLuint Order; /**< Number of control points */
1673 GLfloat u1, u2, du; /**< u1, u2, 1.0/(u2-u1) */
1674 GLfloat *Points; /**< Points to contiguous control points */
1675 };
1676
1677
1678 /**
1679 * 2-D Evaluator control points
1680 */
1681 struct gl_2d_map
1682 {
1683 GLuint Uorder; /**< Number of control points in U dimension */
1684 GLuint Vorder; /**< Number of control points in V dimension */
1685 GLfloat u1, u2, du;
1686 GLfloat v1, v2, dv;
1687 GLfloat *Points; /**< Points to contiguous control points */
1688 };
1689
1690
1691 /**
1692 * All evaluator control point state
1693 */
1694 struct gl_evaluators
1695 {
1696 /**
1697 * \name 1-D maps
1698 */
1699 /*@{*/
1700 struct gl_1d_map Map1Vertex3;
1701 struct gl_1d_map Map1Vertex4;
1702 struct gl_1d_map Map1Index;
1703 struct gl_1d_map Map1Color4;
1704 struct gl_1d_map Map1Normal;
1705 struct gl_1d_map Map1Texture1;
1706 struct gl_1d_map Map1Texture2;
1707 struct gl_1d_map Map1Texture3;
1708 struct gl_1d_map Map1Texture4;
1709 /*@}*/
1710
1711 /**
1712 * \name 2-D maps
1713 */
1714 /*@{*/
1715 struct gl_2d_map Map2Vertex3;
1716 struct gl_2d_map Map2Vertex4;
1717 struct gl_2d_map Map2Index;
1718 struct gl_2d_map Map2Color4;
1719 struct gl_2d_map Map2Normal;
1720 struct gl_2d_map Map2Texture1;
1721 struct gl_2d_map Map2Texture2;
1722 struct gl_2d_map Map2Texture3;
1723 struct gl_2d_map Map2Texture4;
1724 /*@}*/
1725 };
1726
1727
1728 struct gl_transform_feedback_varying_info
1729 {
1730 char *Name;
1731 GLenum16 Type;
1732 GLint BufferIndex;
1733 GLint Size;
1734 GLint Offset;
1735 };
1736
1737
1738 /**
1739 * Per-output info vertex shaders for transform feedback.
1740 */
1741 struct gl_transform_feedback_output
1742 {
1743 uint32_t OutputRegister;
1744 uint32_t OutputBuffer;
1745 uint32_t NumComponents;
1746 uint32_t StreamId;
1747
1748 /** offset (in DWORDs) of this output within the interleaved structure */
1749 uint32_t DstOffset;
1750
1751 /**
1752 * Offset into the output register of the data to output. For example,
1753 * if NumComponents is 2 and ComponentOffset is 1, then the data to
1754 * offset is in the y and z components of the output register.
1755 */
1756 uint32_t ComponentOffset;
1757 };
1758
1759
1760 struct gl_transform_feedback_buffer
1761 {
1762 uint32_t Binding;
1763
1764 uint32_t NumVaryings;
1765
1766 /**
1767 * Total number of components stored in each buffer. This may be used by
1768 * hardware back-ends to determine the correct stride when interleaving
1769 * multiple transform feedback outputs in the same buffer.
1770 */
1771 uint32_t Stride;
1772
1773 /**
1774 * Which transform feedback stream this buffer binding is associated with.
1775 */
1776 uint32_t Stream;
1777 };
1778
1779
1780 /** Post-link transform feedback info. */
1781 struct gl_transform_feedback_info
1782 {
1783 unsigned NumOutputs;
1784
1785 /* Bitmask of active buffer indices. */
1786 unsigned ActiveBuffers;
1787
1788 struct gl_transform_feedback_output *Outputs;
1789
1790 /** Transform feedback varyings used for the linking of this shader program.
1791 *
1792 * Use for glGetTransformFeedbackVarying().
1793 */
1794 struct gl_transform_feedback_varying_info *Varyings;
1795 GLint NumVarying;
1796
1797 struct gl_transform_feedback_buffer Buffers[MAX_FEEDBACK_BUFFERS];
1798 };
1799
1800
1801 /**
1802 * Transform feedback object state
1803 */
1804 struct gl_transform_feedback_object
1805 {
1806 GLuint Name; /**< AKA the object ID */
1807 GLint RefCount;
1808 GLchar *Label; /**< GL_KHR_debug */
1809 GLboolean Active; /**< Is transform feedback enabled? */
1810 GLboolean Paused; /**< Is transform feedback paused? */
1811 GLboolean EndedAnytime; /**< Has EndTransformFeedback been called
1812 at least once? */
1813 GLboolean EverBound; /**< Has this object been bound? */
1814
1815 /**
1816 * GLES: if Active is true, remaining number of primitives which can be
1817 * rendered without overflow. This is necessary to track because GLES
1818 * requires us to generate INVALID_OPERATION if a call to glDrawArrays or
1819 * glDrawArraysInstanced would overflow transform feedback buffers.
1820 * Undefined if Active is false.
1821 *
1822 * Not tracked for desktop GL since it's unnecessary.
1823 */
1824 unsigned GlesRemainingPrims;
1825
1826 /**
1827 * The program active when BeginTransformFeedback() was called.
1828 * When active and unpaused, this equals ctx->Shader.CurrentProgram[stage],
1829 * where stage is the pipeline stage that is the source of data for
1830 * transform feedback.
1831 */
1832 struct gl_program *program;
1833
1834 /** The feedback buffers */
1835 GLuint BufferNames[MAX_FEEDBACK_BUFFERS];
1836 struct gl_buffer_object *Buffers[MAX_FEEDBACK_BUFFERS];
1837
1838 /** Start of feedback data in dest buffer */
1839 GLintptr Offset[MAX_FEEDBACK_BUFFERS];
1840
1841 /**
1842 * Max data to put into dest buffer (in bytes). Computed based on
1843 * RequestedSize and the actual size of the buffer.
1844 */
1845 GLsizeiptr Size[MAX_FEEDBACK_BUFFERS];
1846
1847 /**
1848 * Size that was specified when the buffer was bound. If the buffer was
1849 * bound with glBindBufferBase() or glBindBufferOffsetEXT(), this value is
1850 * zero.
1851 */
1852 GLsizeiptr RequestedSize[MAX_FEEDBACK_BUFFERS];
1853 };
1854
1855
1856 /**
1857 * Context state for transform feedback.
1858 */
1859 struct gl_transform_feedback_state
1860 {
1861 GLenum16 Mode; /**< GL_POINTS, GL_LINES or GL_TRIANGLES */
1862
1863 /** The general binding point (GL_TRANSFORM_FEEDBACK_BUFFER) */
1864 struct gl_buffer_object *CurrentBuffer;
1865
1866 /** The table of all transform feedback objects */
1867 struct _mesa_HashTable *Objects;
1868
1869 /** The current xform-fb object (GL_TRANSFORM_FEEDBACK_BINDING) */
1870 struct gl_transform_feedback_object *CurrentObject;
1871
1872 /** The default xform-fb object (Name==0) */
1873 struct gl_transform_feedback_object *DefaultObject;
1874 };
1875
1876
1877 /**
1878 * A "performance monitor" as described in AMD_performance_monitor.
1879 */
1880 struct gl_perf_monitor_object
1881 {
1882 GLuint Name;
1883
1884 /** True if the monitor is currently active (Begin called but not End). */
1885 GLboolean Active;
1886
1887 /**
1888 * True if the monitor has ended.
1889 *
1890 * This is distinct from !Active because it may never have began.
1891 */
1892 GLboolean Ended;
1893
1894 /**
1895 * A list of groups with currently active counters.
1896 *
1897 * ActiveGroups[g] == n if there are n counters active from group 'g'.
1898 */
1899 unsigned *ActiveGroups;
1900
1901 /**
1902 * An array of bitsets, subscripted by group ID, then indexed by counter ID.
1903 *
1904 * Checking whether counter 'c' in group 'g' is active can be done via:
1905 *
1906 * BITSET_TEST(ActiveCounters[g], c)
1907 */
1908 GLuint **ActiveCounters;
1909 };
1910
1911
1912 union gl_perf_monitor_counter_value
1913 {
1914 float f;
1915 uint64_t u64;
1916 uint32_t u32;
1917 };
1918
1919
1920 struct gl_perf_monitor_counter
1921 {
1922 /** Human readable name for the counter. */
1923 const char *Name;
1924
1925 /**
1926 * Data type of the counter. Valid values are FLOAT, UNSIGNED_INT,
1927 * UNSIGNED_INT64_AMD, and PERCENTAGE_AMD.
1928 */
1929 GLenum16 Type;
1930
1931 /** Minimum counter value. */
1932 union gl_perf_monitor_counter_value Minimum;
1933
1934 /** Maximum counter value. */
1935 union gl_perf_monitor_counter_value Maximum;
1936 };
1937
1938
1939 struct gl_perf_monitor_group
1940 {
1941 /** Human readable name for the group. */
1942 const char *Name;
1943
1944 /**
1945 * Maximum number of counters in this group which can be active at the
1946 * same time.
1947 */
1948 GLuint MaxActiveCounters;
1949
1950 /** Array of counters within this group. */
1951 const struct gl_perf_monitor_counter *Counters;
1952 GLuint NumCounters;
1953 };
1954
1955
1956 /**
1957 * A query object instance as described in INTEL_performance_query.
1958 *
1959 * NB: We want to keep this and the corresponding backend structure
1960 * relatively lean considering that applications may expect to
1961 * allocate enough objects to be able to query around all draw calls
1962 * in a frame.
1963 */
1964 struct gl_perf_query_object
1965 {
1966 GLuint Id; /**< hash table ID/name */
1967 unsigned Used:1; /**< has been used for 1 or more queries */
1968 unsigned Active:1; /**< inside Begin/EndPerfQuery */
1969 unsigned Ready:1; /**< result is ready? */
1970 };
1971
1972
1973 /**
1974 * Context state for AMD_performance_monitor.
1975 */
1976 struct gl_perf_monitor_state
1977 {
1978 /** Array of performance monitor groups (indexed by group ID) */
1979 const struct gl_perf_monitor_group *Groups;
1980 GLuint NumGroups;
1981
1982 /** The table of all performance monitors. */
1983 struct _mesa_HashTable *Monitors;
1984 };
1985
1986
1987 /**
1988 * Context state for INTEL_performance_query.
1989 */
1990 struct gl_perf_query_state
1991 {
1992 struct _mesa_HashTable *Objects; /**< The table of all performance query objects */
1993 };
1994
1995
1996 /**
1997 * A bindless sampler object.
1998 */
1999 struct gl_bindless_sampler
2000 {
2001 /** Texture unit (set by glUniform1()). */
2002 GLubyte unit;
2003
2004 /** Whether this bindless sampler is bound to a unit. */
2005 GLboolean bound;
2006
2007 /** Texture Target (TEXTURE_1D/2D/3D/etc_INDEX). */
2008 gl_texture_index target;
2009
2010 /** Pointer to the base of the data. */
2011 GLvoid *data;
2012 };
2013
2014
2015 /**
2016 * A bindless image object.
2017 */
2018 struct gl_bindless_image
2019 {
2020 /** Image unit (set by glUniform1()). */
2021 GLubyte unit;
2022
2023 /** Whether this bindless image is bound to a unit. */
2024 GLboolean bound;
2025
2026 /** Access qualifier (GL_READ_WRITE, GL_READ_ONLY, GL_WRITE_ONLY, or
2027 * GL_NONE to indicate both read-only and write-only)
2028 */
2029 GLenum16 access;
2030
2031 /** Pointer to the base of the data. */
2032 GLvoid *data;
2033 };
2034
2035
2036 /**
2037 * Current vertex processing mode: fixed function vs. shader.
2038 * In reality, fixed function is probably implemented by a shader but that's
2039 * not what we care about here.
2040 */
2041 typedef enum
2042 {
2043 VP_MODE_FF, /**< legacy / fixed function */
2044 VP_MODE_SHADER, /**< ARB vertex program or GLSL vertex shader */
2045 VP_MODE_MAX /**< for sizing arrays */
2046 } gl_vertex_processing_mode;
2047
2048
2049 /**
2050 * Base class for any kind of program object
2051 */
2052 struct gl_program
2053 {
2054 /** FIXME: This must be first until we split shader_info from nir_shader */
2055 struct shader_info info;
2056
2057 GLuint Id;
2058 GLint RefCount;
2059 GLubyte *String; /**< Null-terminated program text */
2060
2061 /** GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_GEOMETRY_PROGRAM_NV */
2062 GLenum16 Target;
2063 GLenum16 Format; /**< String encoding format */
2064
2065 GLboolean _Used; /**< Ever used for drawing? Used for debugging */
2066
2067 struct nir_shader *nir;
2068
2069 /* Saved and restored with metadata. Freed with ralloc. */
2070 void *driver_cache_blob;
2071 size_t driver_cache_blob_size;
2072
2073 bool is_arb_asm; /** Is this an ARB assembly-style program */
2074
2075 /** Is this program written to on disk shader cache */
2076 bool program_written_to_cache;
2077
2078 /** A bitfield indicating which vertex shader inputs consume two slots
2079 *
2080 * This is used for mapping from single-slot input locations in the GL API
2081 * to dual-slot double input locations in the shader. This field is set
2082 * once as part of linking and never updated again to ensure the mapping
2083 * remains consistent.
2084 *
2085 * Note: There may be dual-slot variables in the original shader source
2086 * which do not appear in this bitfield due to having been eliminated by
2087 * the compiler prior to DualSlotInputs being calculated. There may also
2088 * be bits set in this bitfield which are set but which the shader never
2089 * reads due to compiler optimizations eliminating such variables after
2090 * DualSlotInputs is calculated.
2091 */
2092 GLbitfield64 DualSlotInputs;
2093 /** Subset of OutputsWritten outputs written with non-zero index. */
2094 GLbitfield64 SecondaryOutputsWritten;
2095 /** TEXTURE_x_BIT bitmask */
2096 GLbitfield16 TexturesUsed[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
2097 /** Bitfield of which samplers are used */
2098 GLbitfield SamplersUsed;
2099 /** Texture units used for shadow sampling. */
2100 GLbitfield ShadowSamplers;
2101 /** Texture units used for samplerExternalOES */
2102 GLbitfield ExternalSamplersUsed;
2103
2104 /** Named parameters, constants, etc. from program text */
2105 struct gl_program_parameter_list *Parameters;
2106
2107 /** Map from sampler unit to texture unit (set by glUniform1i()) */
2108 GLubyte SamplerUnits[MAX_SAMPLERS];
2109
2110 /* FIXME: We should be able to make this struct a union. However some
2111 * drivers (i915/fragment_programs, swrast/prog_execute) mix the use of
2112 * these fields, we should fix this.
2113 */
2114 struct {
2115 /** Fields used by GLSL programs */
2116 struct {
2117 /** Data shared by gl_program and gl_shader_program */
2118 struct gl_shader_program_data *data;
2119
2120 struct gl_active_atomic_buffer **AtomicBuffers;
2121
2122 /** Post-link transform feedback info. */
2123 struct gl_transform_feedback_info *LinkedTransformFeedback;
2124
2125 /**
2126 * Number of types for subroutine uniforms.
2127 */
2128 GLuint NumSubroutineUniformTypes;
2129
2130 /**
2131 * Subroutine uniform remap table
2132 * based on the program level uniform remap table.
2133 */
2134 GLuint NumSubroutineUniforms; /* non-sparse total */
2135 GLuint NumSubroutineUniformRemapTable;
2136 struct gl_uniform_storage **SubroutineUniformRemapTable;
2137
2138 /**
2139 * Num of subroutine functions for this stage and storage for them.
2140 */
2141 GLuint NumSubroutineFunctions;
2142 GLuint MaxSubroutineFunctionIndex;
2143 struct gl_subroutine_function *SubroutineFunctions;
2144
2145 /**
2146 * Map from image uniform index to image unit (set by glUniform1i())
2147 *
2148 * An image uniform index is associated with each image uniform by
2149 * the linker. The image index associated with each uniform is
2150 * stored in the \c gl_uniform_storage::image field.
2151 */
2152 GLubyte ImageUnits[MAX_IMAGE_UNIFORMS];
2153
2154 /**
2155 * Access qualifier specified in the shader for each image uniform
2156 * index. Either \c GL_READ_ONLY, \c GL_WRITE_ONLY, \c
2157 * GL_READ_WRITE, or \c GL_NONE to indicate both read-only and
2158 * write-only.
2159 *
2160 * It may be different, though only more strict than the value of
2161 * \c gl_image_unit::Access for the corresponding image unit.
2162 */
2163 GLenum16 ImageAccess[MAX_IMAGE_UNIFORMS];
2164
2165 struct gl_uniform_block **UniformBlocks;
2166 struct gl_uniform_block **ShaderStorageBlocks;
2167
2168 /**
2169 * Bitmask of shader storage blocks not declared as read-only.
2170 */
2171 unsigned ShaderStorageBlocksWriteAccess;
2172
2173 /** Which texture target is being sampled
2174 * (TEXTURE_1D/2D/3D/etc_INDEX)
2175 */
2176 GLubyte SamplerTargets[MAX_SAMPLERS];
2177
2178 /**
2179 * Number of samplers declared with the bindless_sampler layout
2180 * qualifier as specified by ARB_bindless_texture.
2181 */
2182 GLuint NumBindlessSamplers;
2183 GLboolean HasBoundBindlessSampler;
2184 struct gl_bindless_sampler *BindlessSamplers;
2185
2186 /**
2187 * Number of images declared with the bindless_image layout qualifier
2188 * as specified by ARB_bindless_texture.
2189 */
2190 GLuint NumBindlessImages;
2191 GLboolean HasBoundBindlessImage;
2192 struct gl_bindless_image *BindlessImages;
2193
2194 union {
2195 struct {
2196 /**
2197 * A bitmask of gl_advanced_blend_mode values
2198 */
2199 GLbitfield BlendSupport;
2200 } fs;
2201 };
2202 } sh;
2203
2204 /** ARB assembly-style program fields */
2205 struct {
2206 struct prog_instruction *Instructions;
2207
2208 /**
2209 * Local parameters used by the program.
2210 *
2211 * It's dynamically allocated because it is rarely used (just
2212 * assembly-style programs), and MAX_PROGRAM_LOCAL_PARAMS entries
2213 * once it's allocated.
2214 */
2215 GLfloat (*LocalParams)[4];
2216
2217 /** Bitmask of which register files are read/written with indirect
2218 * addressing. Mask of (1 << PROGRAM_x) bits.
2219 */
2220 GLbitfield IndirectRegisterFiles;
2221
2222 /** Logical counts */
2223 /*@{*/
2224 GLuint NumInstructions;
2225 GLuint NumTemporaries;
2226 GLuint NumParameters;
2227 GLuint NumAttributes;
2228 GLuint NumAddressRegs;
2229 GLuint NumAluInstructions;
2230 GLuint NumTexInstructions;
2231 GLuint NumTexIndirections;
2232 /*@}*/
2233 /** Native, actual h/w counts */
2234 /*@{*/
2235 GLuint NumNativeInstructions;
2236 GLuint NumNativeTemporaries;
2237 GLuint NumNativeParameters;
2238 GLuint NumNativeAttributes;
2239 GLuint NumNativeAddressRegs;
2240 GLuint NumNativeAluInstructions;
2241 GLuint NumNativeTexInstructions;
2242 GLuint NumNativeTexIndirections;
2243 /*@}*/
2244
2245 /** Used by ARB assembly-style programs. Can only be true for vertex
2246 * programs.
2247 */
2248 GLboolean IsPositionInvariant;
2249 } arb;
2250 };
2251 };
2252
2253
2254 /**
2255 * State common to vertex and fragment programs.
2256 */
2257 struct gl_program_state
2258 {
2259 GLint ErrorPos; /* GL_PROGRAM_ERROR_POSITION_ARB/NV */
2260 const char *ErrorString; /* GL_PROGRAM_ERROR_STRING_ARB/NV */
2261 };
2262
2263
2264 /**
2265 * Context state for vertex programs.
2266 */
2267 struct gl_vertex_program_state
2268 {
2269 GLboolean Enabled; /**< User-set GL_VERTEX_PROGRAM_ARB/NV flag */
2270 GLboolean PointSizeEnabled; /**< GL_VERTEX_PROGRAM_POINT_SIZE_ARB/NV */
2271 GLboolean TwoSideEnabled; /**< GL_VERTEX_PROGRAM_TWO_SIDE_ARB/NV */
2272 /** Should fixed-function T&L be implemented with a vertex prog? */
2273 GLboolean _MaintainTnlProgram;
2274
2275 struct gl_program *Current; /**< User-bound vertex program */
2276
2277 /** Currently enabled and valid vertex program (including internal
2278 * programs, user-defined vertex programs and GLSL vertex shaders).
2279 * This is the program we must use when rendering.
2280 */
2281 struct gl_program *_Current;
2282
2283 GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */
2284
2285 /** Program to emulate fixed-function T&L (see above) */
2286 struct gl_program *_TnlProgram;
2287
2288 /** Cache of fixed-function programs */
2289 struct gl_program_cache *Cache;
2290
2291 GLboolean _Overriden;
2292
2293 /**
2294 * If we have a vertex program, a TNL program or no program at all.
2295 * Note that this value should be kept up to date all the time,
2296 * nevertheless its correctness is asserted in _mesa_update_state.
2297 * The reason is to avoid calling _mesa_update_state twice we need
2298 * this value on draw *before* actually calling _mesa_update_state.
2299 * Also it should need to get recomputed only on changes to the
2300 * vertex program which are heavyweight already.
2301 */
2302 gl_vertex_processing_mode _VPMode;
2303 };
2304
2305 /**
2306 * Context state for tessellation control programs.
2307 */
2308 struct gl_tess_ctrl_program_state
2309 {
2310 /** Currently bound and valid shader. */
2311 struct gl_program *_Current;
2312
2313 GLint patch_vertices;
2314 GLfloat patch_default_outer_level[4];
2315 GLfloat patch_default_inner_level[2];
2316 };
2317
2318 /**
2319 * Context state for tessellation evaluation programs.
2320 */
2321 struct gl_tess_eval_program_state
2322 {
2323 /** Currently bound and valid shader. */
2324 struct gl_program *_Current;
2325 };
2326
2327 /**
2328 * Context state for geometry programs.
2329 */
2330 struct gl_geometry_program_state
2331 {
2332 /**
2333 * Currently enabled and valid program (including internal programs
2334 * and compiled shader programs).
2335 */
2336 struct gl_program *_Current;
2337 };
2338
2339 /**
2340 * Context state for fragment programs.
2341 */
2342 struct gl_fragment_program_state
2343 {
2344 GLboolean Enabled; /**< User-set fragment program enable flag */
2345 /** Should fixed-function texturing be implemented with a fragment prog? */
2346 GLboolean _MaintainTexEnvProgram;
2347
2348 struct gl_program *Current; /**< User-bound fragment program */
2349
2350 /**
2351 * Currently enabled and valid fragment program (including internal
2352 * programs, user-defined fragment programs and GLSL fragment shaders).
2353 * This is the program we must use when rendering.
2354 */
2355 struct gl_program *_Current;
2356
2357 GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */
2358
2359 /** Program to emulate fixed-function texture env/combine (see above) */
2360 struct gl_program *_TexEnvProgram;
2361
2362 /** Cache of fixed-function programs */
2363 struct gl_program_cache *Cache;
2364 };
2365
2366
2367 /**
2368 * Context state for compute programs.
2369 */
2370 struct gl_compute_program_state
2371 {
2372 /** Currently enabled and valid program (including internal programs
2373 * and compiled shader programs).
2374 */
2375 struct gl_program *_Current;
2376 };
2377
2378
2379 /**
2380 * ATI_fragment_shader runtime state
2381 */
2382
2383 struct atifs_instruction;
2384 struct atifs_setupinst;
2385
2386 /**
2387 * ATI fragment shader
2388 */
2389 struct ati_fragment_shader
2390 {
2391 GLuint Id;
2392 GLint RefCount;
2393 struct atifs_instruction *Instructions[2];
2394 struct atifs_setupinst *SetupInst[2];
2395 GLfloat Constants[8][4];
2396 GLbitfield LocalConstDef; /**< Indicates which constants have been set */
2397 GLubyte numArithInstr[2];
2398 GLubyte regsAssigned[2];
2399 GLubyte NumPasses; /**< 1 or 2 */
2400 /**
2401 * Current compile stage: 0 setup pass1, 1 arith pass1,
2402 * 2 setup pass2, 3 arith pass2.
2403 */
2404 GLubyte cur_pass;
2405 GLubyte last_optype;
2406 GLboolean interpinp1;
2407 GLboolean isValid;
2408 /**
2409 * Array of 2 bit values for each tex unit to remember whether
2410 * STR or STQ swizzle was used
2411 */
2412 GLuint swizzlerq;
2413 struct gl_program *Program;
2414 };
2415
2416 /**
2417 * Context state for GL_ATI_fragment_shader
2418 */
2419 struct gl_ati_fragment_shader_state
2420 {
2421 GLboolean Enabled;
2422 GLboolean Compiling;
2423 GLfloat GlobalConstants[8][4];
2424 struct ati_fragment_shader *Current;
2425 };
2426
2427 /**
2428 * Shader subroutine function definition
2429 */
2430 struct gl_subroutine_function
2431 {
2432 char *name;
2433 int index;
2434 int num_compat_types;
2435 const struct glsl_type **types;
2436 };
2437
2438 /**
2439 * Shader information needed by both gl_shader and gl_linked shader.
2440 */
2441 struct gl_shader_info
2442 {
2443 /**
2444 * Tessellation Control shader state from layout qualifiers.
2445 */
2446 struct {
2447 /**
2448 * 0 - vertices not declared in shader, or
2449 * 1 .. GL_MAX_PATCH_VERTICES
2450 */
2451 GLint VerticesOut;
2452 } TessCtrl;
2453
2454 /**
2455 * Tessellation Evaluation shader state from layout qualifiers.
2456 */
2457 struct {
2458 /**
2459 * GL_TRIANGLES, GL_QUADS, GL_ISOLINES or PRIM_UNKNOWN if it's not set
2460 * in this shader.
2461 */
2462 GLenum16 PrimitiveMode;
2463
2464 enum gl_tess_spacing Spacing;
2465
2466 /**
2467 * GL_CW, GL_CCW, or 0 if it's not set in this shader.
2468 */
2469 GLenum16 VertexOrder;
2470 /**
2471 * 1, 0, or -1 if it's not set in this shader.
2472 */
2473 int PointMode;
2474 } TessEval;
2475
2476 /**
2477 * Geometry shader state from GLSL 1.50 layout qualifiers.
2478 */
2479 struct {
2480 GLint VerticesOut;
2481 /**
2482 * 0 - Invocations count not declared in shader, or
2483 * 1 .. Const.MaxGeometryShaderInvocations
2484 */
2485 GLint Invocations;
2486 /**
2487 * GL_POINTS, GL_LINES, GL_LINES_ADJACENCY, GL_TRIANGLES, or
2488 * GL_TRIANGLES_ADJACENCY, or PRIM_UNKNOWN if it's not set in this
2489 * shader.
2490 */
2491 GLenum16 InputType;
2492 /**
2493 * GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP, or PRIM_UNKNOWN if
2494 * it's not set in this shader.
2495 */
2496 GLenum16 OutputType;
2497 } Geom;
2498
2499 /**
2500 * Compute shader state from ARB_compute_shader and
2501 * ARB_compute_variable_group_size layout qualifiers.
2502 */
2503 struct {
2504 /**
2505 * Size specified using local_size_{x,y,z}, or all 0's to indicate that
2506 * it's not set in this shader.
2507 */
2508 unsigned LocalSize[3];
2509
2510 /**
2511 * Whether a variable work group size has been specified as defined by
2512 * ARB_compute_variable_group_size.
2513 */
2514 bool LocalSizeVariable;
2515
2516 /*
2517 * Arrangement of invocations used to calculate derivatives in a compute
2518 * shader. From NV_compute_shader_derivatives.
2519 */
2520 enum gl_derivative_group DerivativeGroup;
2521 } Comp;
2522 };
2523
2524 /**
2525 * A linked GLSL shader object.
2526 */
2527 struct gl_linked_shader
2528 {
2529 gl_shader_stage Stage;
2530
2531 #ifdef DEBUG
2532 unsigned SourceChecksum;
2533 #endif
2534
2535 struct gl_program *Program; /**< Post-compile assembly code */
2536
2537 /**
2538 * \name Sampler tracking
2539 *
2540 * \note Each of these fields is only set post-linking.
2541 */
2542 /*@{*/
2543 GLbitfield shadow_samplers; /**< Samplers used for shadow sampling. */
2544 /*@}*/
2545
2546 /**
2547 * Number of default uniform block components used by this shader.
2548 *
2549 * This field is only set post-linking.
2550 */
2551 unsigned num_uniform_components;
2552
2553 /**
2554 * Number of combined uniform components used by this shader.
2555 *
2556 * This field is only set post-linking. It is the sum of the uniform block
2557 * sizes divided by sizeof(float), and num_uniform_compoennts.
2558 */
2559 unsigned num_combined_uniform_components;
2560
2561 struct exec_list *ir;
2562 struct exec_list *packed_varyings;
2563 struct exec_list *fragdata_arrays;
2564 struct glsl_symbol_table *symbols;
2565
2566 /**
2567 * ARB_gl_spirv related data.
2568 *
2569 * This is actually a reference to the gl_shader::spirv_data, which
2570 * stores information that is also needed during linking.
2571 */
2572 struct gl_shader_spirv_data *spirv_data;
2573 };
2574
2575
2576 /**
2577 * Compile status enum. COMPILE_SKIPPED is used to indicate the compile
2578 * was skipped due to the shader matching one that's been seen before by
2579 * the on-disk cache.
2580 */
2581 enum gl_compile_status
2582 {
2583 COMPILE_FAILURE = 0,
2584 COMPILE_SUCCESS,
2585 COMPILE_SKIPPED
2586 };
2587
2588 /**
2589 * A GLSL shader object.
2590 */
2591 struct gl_shader
2592 {
2593 /** GL_FRAGMENT_SHADER || GL_VERTEX_SHADER || GL_GEOMETRY_SHADER_ARB ||
2594 * GL_TESS_CONTROL_SHADER || GL_TESS_EVALUATION_SHADER.
2595 * Must be the first field.
2596 */
2597 GLenum16 Type;
2598 gl_shader_stage Stage;
2599 GLuint Name; /**< AKA the handle */
2600 GLint RefCount; /**< Reference count */
2601 GLchar *Label; /**< GL_KHR_debug */
2602 unsigned char sha1[20]; /**< SHA1 hash of pre-processed source */
2603 GLboolean DeletePending;
2604 bool IsES; /**< True if this shader uses GLSL ES */
2605
2606 enum gl_compile_status CompileStatus;
2607
2608 #ifdef DEBUG
2609 unsigned SourceChecksum; /**< for debug/logging purposes */
2610 #endif
2611 const GLchar *Source; /**< Source code string */
2612
2613 const GLchar *FallbackSource; /**< Fallback string used by on-disk cache*/
2614
2615 GLchar *InfoLog;
2616
2617 unsigned Version; /**< GLSL version used for linking */
2618
2619 /**
2620 * A bitmask of gl_advanced_blend_mode values
2621 */
2622 GLbitfield BlendSupport;
2623
2624 struct exec_list *ir;
2625 struct glsl_symbol_table *symbols;
2626
2627 /**
2628 * Whether early fragment tests are enabled as defined by
2629 * ARB_shader_image_load_store.
2630 */
2631 bool EarlyFragmentTests;
2632
2633 bool ARB_fragment_coord_conventions_enable;
2634
2635 bool redeclares_gl_fragcoord;
2636 bool uses_gl_fragcoord;
2637
2638 bool PostDepthCoverage;
2639 bool PixelInterlockOrdered;
2640 bool PixelInterlockUnordered;
2641 bool SampleInterlockOrdered;
2642 bool SampleInterlockUnordered;
2643 bool InnerCoverage;
2644
2645 /**
2646 * Fragment shader state from GLSL 1.50 layout qualifiers.
2647 */
2648 bool origin_upper_left;
2649 bool pixel_center_integer;
2650
2651 /**
2652 * Whether bindless_sampler/bindless_image, and respectively
2653 * bound_sampler/bound_image are declared at global scope as defined by
2654 * ARB_bindless_texture.
2655 */
2656 bool bindless_sampler;
2657 bool bindless_image;
2658 bool bound_sampler;
2659 bool bound_image;
2660
2661 /** Global xfb_stride out qualifier if any */
2662 GLuint TransformFeedbackBufferStride[MAX_FEEDBACK_BUFFERS];
2663
2664 struct gl_shader_info info;
2665
2666 /* ARB_gl_spirv related data */
2667 struct gl_shader_spirv_data *spirv_data;
2668 };
2669
2670
2671 struct gl_uniform_buffer_variable
2672 {
2673 char *Name;
2674
2675 /**
2676 * Name of the uniform as seen by glGetUniformIndices.
2677 *
2678 * glGetUniformIndices requires that the block instance index \b not be
2679 * present in the name of queried uniforms.
2680 *
2681 * \note
2682 * \c gl_uniform_buffer_variable::IndexName and
2683 * \c gl_uniform_buffer_variable::Name may point to identical storage.
2684 */
2685 char *IndexName;
2686
2687 const struct glsl_type *Type;
2688 unsigned int Offset;
2689 GLboolean RowMajor;
2690 };
2691
2692
2693 struct gl_uniform_block
2694 {
2695 /** Declared name of the uniform block */
2696 char *Name;
2697
2698 /** Array of supplemental information about UBO ir_variables. */
2699 struct gl_uniform_buffer_variable *Uniforms;
2700 GLuint NumUniforms;
2701
2702 /**
2703 * Index (GL_UNIFORM_BLOCK_BINDING) into ctx->UniformBufferBindings[] to use
2704 * with glBindBufferBase to bind a buffer object to this uniform block.
2705 */
2706 GLuint Binding;
2707
2708 /**
2709 * Minimum size (in bytes) of a buffer object to back this uniform buffer
2710 * (GL_UNIFORM_BLOCK_DATA_SIZE).
2711 */
2712 GLuint UniformBufferSize;
2713
2714 /** Stages that reference this block */
2715 uint8_t stageref;
2716
2717 /**
2718 * Linearized array index for uniform block instance arrays
2719 *
2720 * Given a uniform block instance array declared with size
2721 * blk[s_0][s_1]..[s_m], the block referenced by blk[i_0][i_1]..[i_m] will
2722 * have the linearized array index
2723 *
2724 * m-1 m
2725 * i_m + ∑ i_j * ∏ s_k
2726 * j=0 k=j+1
2727 *
2728 * For a uniform block instance that is not an array, this is always 0.
2729 */
2730 uint8_t linearized_array_index;
2731
2732 /**
2733 * Layout specified in the shader
2734 *
2735 * This isn't accessible through the API, but it is used while
2736 * cross-validating uniform blocks.
2737 */
2738 enum glsl_interface_packing _Packing;
2739 GLboolean _RowMajor;
2740 };
2741
2742 /**
2743 * Structure that represents a reference to an atomic buffer from some
2744 * shader program.
2745 */
2746 struct gl_active_atomic_buffer
2747 {
2748 /** Uniform indices of the atomic counters declared within it. */
2749 GLuint *Uniforms;
2750 GLuint NumUniforms;
2751
2752 /** Binding point index associated with it. */
2753 GLuint Binding;
2754
2755 /** Minimum reasonable size it is expected to have. */
2756 GLuint MinimumSize;
2757
2758 /** Shader stages making use of it. */
2759 GLboolean StageReferences[MESA_SHADER_STAGES];
2760 };
2761
2762 /**
2763 * Data container for shader queries. This holds only the minimal
2764 * amount of required information for resource queries to work.
2765 */
2766 struct gl_shader_variable
2767 {
2768 /**
2769 * Declared type of the variable
2770 */
2771 const struct glsl_type *type;
2772
2773 /**
2774 * If the variable is in an interface block, this is the type of the block.
2775 */
2776 const struct glsl_type *interface_type;
2777
2778 /**
2779 * For variables inside structs (possibly recursively), this is the
2780 * outermost struct type.
2781 */
2782 const struct glsl_type *outermost_struct_type;
2783
2784 /**
2785 * Declared name of the variable
2786 */
2787 char *name;
2788
2789 /**
2790 * Storage location of the base of this variable
2791 *
2792 * The precise meaning of this field depends on the nature of the variable.
2793 *
2794 * - Vertex shader input: one of the values from \c gl_vert_attrib.
2795 * - Vertex shader output: one of the values from \c gl_varying_slot.
2796 * - Geometry shader input: one of the values from \c gl_varying_slot.
2797 * - Geometry shader output: one of the values from \c gl_varying_slot.
2798 * - Fragment shader input: one of the values from \c gl_varying_slot.
2799 * - Fragment shader output: one of the values from \c gl_frag_result.
2800 * - Uniforms: Per-stage uniform slot number for default uniform block.
2801 * - Uniforms: Index within the uniform block definition for UBO members.
2802 * - Non-UBO Uniforms: explicit location until linking then reused to
2803 * store uniform slot number.
2804 * - Other: This field is not currently used.
2805 *
2806 * If the variable is a uniform, shader input, or shader output, and the
2807 * slot has not been assigned, the value will be -1.
2808 */
2809 int location;
2810
2811 /**
2812 * Specifies the first component the variable is stored in as per
2813 * ARB_enhanced_layouts.
2814 */
2815 unsigned component:2;
2816
2817 /**
2818 * Output index for dual source blending.
2819 *
2820 * \note
2821 * The GLSL spec only allows the values 0 or 1 for the index in \b dual
2822 * source blending.
2823 */
2824 unsigned index:1;
2825
2826 /**
2827 * Specifies whether a shader input/output is per-patch in tessellation
2828 * shader stages.
2829 */
2830 unsigned patch:1;
2831
2832 /**
2833 * Storage class of the variable.
2834 *
2835 * \sa (n)ir_variable_mode
2836 */
2837 unsigned mode:4;
2838
2839 /**
2840 * Interpolation mode for shader inputs / outputs
2841 *
2842 * \sa glsl_interp_mode
2843 */
2844 unsigned interpolation:2;
2845
2846 /**
2847 * Was the location explicitly set in the shader?
2848 *
2849 * If the location is explicitly set in the shader, it \b cannot be changed
2850 * by the linker or by the API (e.g., calls to \c glBindAttribLocation have
2851 * no effect).
2852 */
2853 unsigned explicit_location:1;
2854
2855 /**
2856 * Precision qualifier.
2857 */
2858 unsigned precision:2;
2859 };
2860
2861 /**
2862 * Active resource in a gl_shader_program
2863 */
2864 struct gl_program_resource
2865 {
2866 GLenum16 Type; /** Program interface type. */
2867 const void *Data; /** Pointer to resource associated data structure. */
2868 uint8_t StageReferences; /** Bitmask of shader stage references. */
2869 };
2870
2871 /**
2872 * Link status enum. LINKING_SKIPPED is used to indicate linking
2873 * was skipped due to the shader being loaded from the on-disk cache.
2874 */
2875 enum gl_link_status
2876 {
2877 LINKING_FAILURE = 0,
2878 LINKING_SUCCESS,
2879 LINKING_SKIPPED
2880 };
2881
2882 /**
2883 * A data structure to be shared by gl_shader_program and gl_program.
2884 */
2885 struct gl_shader_program_data
2886 {
2887 GLint RefCount; /**< Reference count */
2888
2889 /** SHA1 hash of linked shader program */
2890 unsigned char sha1[20];
2891
2892 unsigned NumUniformStorage;
2893 unsigned NumHiddenUniforms;
2894 struct gl_uniform_storage *UniformStorage;
2895
2896 unsigned NumUniformBlocks;
2897 unsigned NumShaderStorageBlocks;
2898
2899 struct gl_uniform_block *UniformBlocks;
2900 struct gl_uniform_block *ShaderStorageBlocks;
2901
2902 struct gl_active_atomic_buffer *AtomicBuffers;
2903 unsigned NumAtomicBuffers;
2904
2905 /* Shader cache variables used during restore */
2906 unsigned NumUniformDataSlots;
2907 union gl_constant_value *UniformDataSlots;
2908
2909 /* Used to hold initial uniform values for program binary restores.
2910 *
2911 * From the ARB_get_program_binary spec:
2912 *
2913 * "A successful call to ProgramBinary will reset all uniform
2914 * variables to their initial values. The initial value is either
2915 * the value of the variable's initializer as specified in the
2916 * original shader source, or 0 if no initializer was present.
2917 */
2918 union gl_constant_value *UniformDataDefaults;
2919
2920 /** Hash for quick search by name. */
2921 struct hash_table_u64 *ProgramResourceHash;
2922
2923 GLboolean Validated;
2924
2925 /** List of all active resources after linking. */
2926 struct gl_program_resource *ProgramResourceList;
2927 unsigned NumProgramResourceList;
2928
2929 enum gl_link_status LinkStatus; /**< GL_LINK_STATUS */
2930 GLchar *InfoLog;
2931
2932 unsigned Version; /**< GLSL version used for linking */
2933
2934 /* Mask of stages this program was linked against */
2935 unsigned linked_stages;
2936
2937 /* Whether the shaders of this program are loaded from SPIR-V binaries
2938 * (all have the SPIR_V_BINARY_ARB state). This was introduced by the
2939 * ARB_gl_spirv extension.
2940 */
2941 bool spirv;
2942 };
2943
2944 /**
2945 * A GLSL program object.
2946 * Basically a linked collection of vertex and fragment shaders.
2947 */
2948 struct gl_shader_program
2949 {
2950 GLenum16 Type; /**< Always GL_SHADER_PROGRAM (internal token) */
2951 GLuint Name; /**< aka handle or ID */
2952 GLchar *Label; /**< GL_KHR_debug */
2953 GLint RefCount; /**< Reference count */
2954 GLboolean DeletePending;
2955
2956 /**
2957 * Is the application intending to glGetProgramBinary this program?
2958 *
2959 * BinaryRetrievableHint is the currently active hint that gets set
2960 * during initialization and after linking and BinaryRetrievableHintPending
2961 * is the hint set by the user to be active when program is linked next time.
2962 */
2963 GLboolean BinaryRetrievableHint;
2964 GLboolean BinaryRetrievableHintPending;
2965
2966 /**
2967 * Indicates whether program can be bound for individual pipeline stages
2968 * using UseProgramStages after it is next linked.
2969 */
2970 GLboolean SeparateShader;
2971
2972 GLuint NumShaders; /**< number of attached shaders */
2973 struct gl_shader **Shaders; /**< List of attached the shaders */
2974
2975 /**
2976 * User-defined attribute bindings
2977 *
2978 * These are set via \c glBindAttribLocation and are used to direct the
2979 * GLSL linker. These are \b not the values used in the compiled shader,
2980 * and they are \b not the values returned by \c glGetAttribLocation.
2981 */
2982 struct string_to_uint_map *AttributeBindings;
2983
2984 /**
2985 * User-defined fragment data bindings
2986 *
2987 * These are set via \c glBindFragDataLocation and are used to direct the
2988 * GLSL linker. These are \b not the values used in the compiled shader,
2989 * and they are \b not the values returned by \c glGetFragDataLocation.
2990 */
2991 struct string_to_uint_map *FragDataBindings;
2992 struct string_to_uint_map *FragDataIndexBindings;
2993
2994 /**
2995 * Transform feedback varyings last specified by
2996 * glTransformFeedbackVaryings().
2997 *
2998 * For the current set of transform feedback varyings used for transform
2999 * feedback output, see LinkedTransformFeedback.
3000 */
3001 struct {
3002 GLenum16 BufferMode;
3003 /** Global xfb_stride out qualifier if any */
3004 GLuint BufferStride[MAX_FEEDBACK_BUFFERS];
3005 GLuint NumVarying;
3006 GLchar **VaryingNames; /**< Array [NumVarying] of char * */
3007 } TransformFeedback;
3008
3009 struct gl_program *last_vert_prog;
3010
3011 /** Post-link gl_FragDepth layout for ARB_conservative_depth. */
3012 enum gl_frag_depth_layout FragDepthLayout;
3013
3014 /**
3015 * Geometry shader state - copied into gl_program by
3016 * _mesa_copy_linked_program_data().
3017 */
3018 struct {
3019 GLint VerticesIn;
3020
3021 bool UsesEndPrimitive;
3022 bool UsesStreams;
3023 } Geom;
3024
3025 /**
3026 * Compute shader state - copied into gl_program by
3027 * _mesa_copy_linked_program_data().
3028 */
3029 struct {
3030 /**
3031 * Size of shared variables accessed by the compute shader.
3032 */
3033 unsigned SharedSize;
3034 } Comp;
3035
3036 /** Data shared by gl_program and gl_shader_program */
3037 struct gl_shader_program_data *data;
3038
3039 /**
3040 * Mapping from GL uniform locations returned by \c glUniformLocation to
3041 * UniformStorage entries. Arrays will have multiple contiguous slots
3042 * in the UniformRemapTable, all pointing to the same UniformStorage entry.
3043 */
3044 unsigned NumUniformRemapTable;
3045 struct gl_uniform_storage **UniformRemapTable;
3046
3047 /**
3048 * Sometimes there are empty slots left over in UniformRemapTable after we
3049 * allocate slots to explicit locations. This list stores the blocks of
3050 * continuous empty slots inside UniformRemapTable.
3051 */
3052 struct exec_list EmptyUniformLocations;
3053
3054 /**
3055 * Total number of explicit uniform location including inactive uniforms.
3056 */
3057 unsigned NumExplicitUniformLocations;
3058
3059 /**
3060 * Map of active uniform names to locations
3061 *
3062 * Maps any active uniform that is not an array element to a location.
3063 * Each active uniform, including individual structure members will appear
3064 * in this map. This roughly corresponds to the set of names that would be
3065 * enumerated by \c glGetActiveUniform.
3066 */
3067 struct string_to_uint_map *UniformHash;
3068
3069 GLboolean SamplersValidated; /**< Samplers validated against texture units? */
3070
3071 bool IsES; /**< True if this program uses GLSL ES */
3072
3073 /**
3074 * Per-stage shaders resulting from the first stage of linking.
3075 *
3076 * Set of linked shaders for this program. The array is accessed using the
3077 * \c MESA_SHADER_* defines. Entries for non-existent stages will be
3078 * \c NULL.
3079 */
3080 struct gl_linked_shader *_LinkedShaders[MESA_SHADER_STAGES];
3081
3082 /**
3083 * True if any of the fragment shaders attached to this program use:
3084 * #extension ARB_fragment_coord_conventions: enable
3085 */
3086 GLboolean ARB_fragment_coord_conventions_enable;
3087 };
3088
3089
3090 #define GLSL_DUMP 0x1 /**< Dump shaders to stdout */
3091 #define GLSL_LOG 0x2 /**< Write shaders to files */
3092 #define GLSL_UNIFORMS 0x4 /**< Print glUniform calls */
3093 #define GLSL_NOP_VERT 0x8 /**< Force no-op vertex shaders */
3094 #define GLSL_NOP_FRAG 0x10 /**< Force no-op fragment shaders */
3095 #define GLSL_USE_PROG 0x20 /**< Log glUseProgram calls */
3096 #define GLSL_REPORT_ERRORS 0x40 /**< Print compilation errors */
3097 #define GLSL_DUMP_ON_ERROR 0x80 /**< Dump shaders to stderr on compile error */
3098 #define GLSL_CACHE_INFO 0x100 /**< Print debug information about shader cache */
3099 #define GLSL_CACHE_FALLBACK 0x200 /**< Force shader cache fallback paths */
3100
3101
3102 /**
3103 * Context state for GLSL vertex/fragment shaders.
3104 * Extended to support pipeline object
3105 */
3106 struct gl_pipeline_object
3107 {
3108 /** Name of the pipeline object as received from glGenProgramPipelines.
3109 * It would be 0 for shaders without separate shader objects.
3110 */
3111 GLuint Name;
3112
3113 GLint RefCount;
3114
3115 GLchar *Label; /**< GL_KHR_debug */
3116
3117 /**
3118 * Programs used for rendering
3119 *
3120 * There is a separate program set for each shader stage.
3121 */
3122 struct gl_program *CurrentProgram[MESA_SHADER_STAGES];
3123
3124 struct gl_shader_program *ReferencedPrograms[MESA_SHADER_STAGES];
3125
3126 /**
3127 * Program used by glUniform calls.
3128 *
3129 * Explicitly set by \c glUseProgram and \c glActiveProgramEXT.
3130 */
3131 struct gl_shader_program *ActiveProgram;
3132
3133 GLbitfield Flags; /**< Mask of GLSL_x flags */
3134 GLboolean EverBound; /**< Has the pipeline object been created */
3135 GLboolean Validated; /**< Pipeline Validation status */
3136
3137 GLchar *InfoLog;
3138 };
3139
3140 /**
3141 * Context state for GLSL pipeline shaders.
3142 */
3143 struct gl_pipeline_shader_state
3144 {
3145 /** Currently bound pipeline object. See _mesa_BindProgramPipeline() */
3146 struct gl_pipeline_object *Current;
3147
3148 /** Default Object to ensure that _Shader is never NULL */
3149 struct gl_pipeline_object *Default;
3150
3151 /** Pipeline objects */
3152 struct _mesa_HashTable *Objects;
3153 };
3154
3155 /**
3156 * Compiler options for a single GLSL shaders type
3157 */
3158 struct gl_shader_compiler_options
3159 {
3160 /** Driver-selectable options: */
3161 GLboolean EmitNoLoops;
3162 GLboolean EmitNoCont; /**< Emit CONT opcode? */
3163 GLboolean EmitNoMainReturn; /**< Emit CONT/RET opcodes? */
3164 GLboolean EmitNoPow; /**< Emit POW opcodes? */
3165 GLboolean EmitNoSat; /**< Emit SAT opcodes? */
3166 GLboolean LowerCombinedClipCullDistance; /** Lower gl_ClipDistance and
3167 * gl_CullDistance together from
3168 * float[8] to vec4[2]
3169 **/
3170
3171 /**
3172 * \name Forms of indirect addressing the driver cannot do.
3173 */
3174 /*@{*/
3175 GLboolean EmitNoIndirectInput; /**< No indirect addressing of inputs */
3176 GLboolean EmitNoIndirectOutput; /**< No indirect addressing of outputs */
3177 GLboolean EmitNoIndirectTemp; /**< No indirect addressing of temps */
3178 GLboolean EmitNoIndirectUniform; /**< No indirect addressing of constants */
3179 GLboolean EmitNoIndirectSampler; /**< No indirect addressing of samplers */
3180 /*@}*/
3181
3182 GLuint MaxIfDepth; /**< Maximum nested IF blocks */
3183 GLuint MaxUnrollIterations;
3184
3185 /**
3186 * Optimize code for array of structures backends.
3187 *
3188 * This is a proxy for:
3189 * - preferring DP4 instructions (rather than MUL/MAD) for
3190 * matrix * vector operations, such as position transformation.
3191 */
3192 GLboolean OptimizeForAOS;
3193
3194 /** Lower UBO and SSBO access to intrinsics. */
3195 GLboolean LowerBufferInterfaceBlocks;
3196
3197 /** Clamp UBO and SSBO block indices so they don't go out-of-bounds. */
3198 GLboolean ClampBlockIndicesToArrayBounds;
3199
3200 /** (driconf) Force gl_Position to be considered invariant */
3201 GLboolean PositionAlwaysInvariant;
3202
3203 const struct nir_shader_compiler_options *NirOptions;
3204 };
3205
3206
3207 /**
3208 * Occlusion/timer query object.
3209 */
3210 struct gl_query_object
3211 {
3212 GLenum16 Target; /**< The query target, when active */
3213 GLuint Id; /**< hash table ID/name */
3214 GLchar *Label; /**< GL_KHR_debug */
3215 GLuint64EXT Result; /**< the counter */
3216 GLboolean Active; /**< inside Begin/EndQuery */
3217 GLboolean Ready; /**< result is ready? */
3218 GLboolean EverBound;/**< has query object ever been bound */
3219 GLuint Stream; /**< The stream */
3220 };
3221
3222
3223 /**
3224 * Context state for query objects.
3225 */
3226 struct gl_query_state
3227 {
3228 struct _mesa_HashTable *QueryObjects;
3229 struct gl_query_object *CurrentOcclusionObject; /* GL_ARB_occlusion_query */
3230 struct gl_query_object *CurrentTimerObject; /* GL_EXT_timer_query */
3231
3232 /** GL_NV_conditional_render */
3233 struct gl_query_object *CondRenderQuery;
3234
3235 /** GL_EXT_transform_feedback */
3236 struct gl_query_object *PrimitivesGenerated[MAX_VERTEX_STREAMS];
3237 struct gl_query_object *PrimitivesWritten[MAX_VERTEX_STREAMS];
3238
3239 /** GL_ARB_transform_feedback_overflow_query */
3240 struct gl_query_object *TransformFeedbackOverflow[MAX_VERTEX_STREAMS];
3241 struct gl_query_object *TransformFeedbackOverflowAny;
3242
3243 /** GL_ARB_timer_query */
3244 struct gl_query_object *TimeElapsed;
3245
3246 /** GL_ARB_pipeline_statistics_query */
3247 struct gl_query_object *pipeline_stats[MAX_PIPELINE_STATISTICS];
3248
3249 GLenum16 CondRenderMode;
3250 };
3251
3252
3253 /** Sync object state */
3254 struct gl_sync_object
3255 {
3256 GLuint Name; /**< Fence name */
3257 GLint RefCount; /**< Reference count */
3258 GLchar *Label; /**< GL_KHR_debug */
3259 GLboolean DeletePending; /**< Object was deleted while there were still
3260 * live references (e.g., sync not yet finished)
3261 */
3262 GLenum16 SyncCondition;
3263 GLbitfield Flags; /**< Flags passed to glFenceSync */
3264 GLuint StatusFlag:1; /**< Has the sync object been signaled? */
3265 };
3266
3267
3268 /**
3269 * State which can be shared by multiple contexts:
3270 */
3271 struct gl_shared_state
3272 {
3273 simple_mtx_t Mutex; /**< for thread safety */
3274 GLint RefCount; /**< Reference count */
3275 struct _mesa_HashTable *DisplayList; /**< Display lists hash table */
3276 struct _mesa_HashTable *BitmapAtlas; /**< For optimized glBitmap text */
3277 struct _mesa_HashTable *TexObjects; /**< Texture objects hash table */
3278
3279 /** Default texture objects (shared by all texture units) */
3280 struct gl_texture_object *DefaultTex[NUM_TEXTURE_TARGETS];
3281
3282 /** Fallback texture used when a bound texture is incomplete */
3283 struct gl_texture_object *FallbackTex[NUM_TEXTURE_TARGETS];
3284
3285 /**
3286 * \name Thread safety and statechange notification for texture
3287 * objects.
3288 *
3289 * \todo Improve the granularity of locking.
3290 */
3291 /*@{*/
3292 mtx_t TexMutex; /**< texobj thread safety */
3293 GLuint TextureStateStamp; /**< state notification for shared tex */
3294 /*@}*/
3295
3296 /** Default buffer object for vertex arrays that aren't in VBOs */
3297 struct gl_buffer_object *NullBufferObj;
3298
3299 /**
3300 * \name Vertex/geometry/fragment programs
3301 */
3302 /*@{*/
3303 struct _mesa_HashTable *Programs; /**< All vertex/fragment programs */
3304 struct gl_program *DefaultVertexProgram;
3305 struct gl_program *DefaultFragmentProgram;
3306 /*@}*/
3307
3308 /* GL_ATI_fragment_shader */
3309 struct _mesa_HashTable *ATIShaders;
3310 struct ati_fragment_shader *DefaultFragmentShader;
3311
3312 struct _mesa_HashTable *BufferObjects;
3313
3314 /** Table of both gl_shader and gl_shader_program objects */
3315 struct _mesa_HashTable *ShaderObjects;
3316
3317 /* GL_EXT_framebuffer_object */
3318 struct _mesa_HashTable *RenderBuffers;
3319 struct _mesa_HashTable *FrameBuffers;
3320
3321 /* GL_ARB_sync */
3322 struct set *SyncObjects;
3323
3324 /** GL_ARB_sampler_objects */
3325 struct _mesa_HashTable *SamplerObjects;
3326
3327 /* GL_ARB_bindless_texture */
3328 struct hash_table_u64 *TextureHandles;
3329 struct hash_table_u64 *ImageHandles;
3330 mtx_t HandlesMutex; /**< For texture/image handles safety */
3331
3332 /* GL_ARB_shading_language_include */
3333 struct shader_includes *ShaderIncludes;
3334 /* glCompileShaderInclude expects ShaderIncludes not to change while it is
3335 * in progress.
3336 */
3337 mtx_t ShaderIncludeMutex;
3338
3339 /**
3340 * Some context in this share group was affected by a GPU reset
3341 *
3342 * On the next call to \c glGetGraphicsResetStatus, contexts that have not
3343 * been affected by a GPU reset must also return
3344 * \c GL_INNOCENT_CONTEXT_RESET_ARB.
3345 *
3346 * Once this field becomes true, it is never reset to false.
3347 */
3348 bool ShareGroupReset;
3349
3350 /** EXT_external_objects */
3351 struct _mesa_HashTable *MemoryObjects;
3352
3353 /** EXT_semaphore */
3354 struct _mesa_HashTable *SemaphoreObjects;
3355
3356 /**
3357 * Some context in this share group was affected by a disjoint
3358 * operation. This operation can be anything that has effects on
3359 * values of timer queries in such manner that they become invalid for
3360 * performance metrics. As example gpu reset, counter overflow or gpu
3361 * frequency changes.
3362 */
3363 bool DisjointOperation;
3364 };
3365
3366
3367
3368 /**
3369 * Renderbuffers represent drawing surfaces such as color, depth and/or
3370 * stencil. A framebuffer object has a set of renderbuffers.
3371 * Drivers will typically derive subclasses of this type.
3372 */
3373 struct gl_renderbuffer
3374 {
3375 simple_mtx_t Mutex; /**< for thread safety */
3376 GLuint ClassID; /**< Useful for drivers */
3377 GLuint Name;
3378 GLchar *Label; /**< GL_KHR_debug */
3379 GLint RefCount;
3380 GLuint Width, Height;
3381 GLuint Depth;
3382 GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */
3383 GLboolean AttachedAnytime; /**< TRUE if it was attached to a framebuffer */
3384 /**
3385 * True for renderbuffers that wrap textures, giving the driver a chance to
3386 * flush render caches through the FinishRenderTexture hook.
3387 *
3388 * Drivers may also set this on renderbuffers other than those generated by
3389 * glFramebufferTexture(), though it means FinishRenderTexture() would be
3390 * called without a rb->TexImage.
3391 */
3392 GLboolean NeedsFinishRenderTexture;
3393 GLubyte NumSamples; /**< zero means not multisampled */
3394 GLubyte NumStorageSamples; /**< for AMD_framebuffer_multisample_advanced */
3395 GLenum16 InternalFormat; /**< The user-specified format */
3396 GLenum16 _BaseFormat; /**< Either GL_RGB, GL_RGBA, GL_DEPTH_COMPONENT or
3397 GL_STENCIL_INDEX. */
3398 mesa_format Format; /**< The actual renderbuffer memory format */
3399 /**
3400 * Pointer to the texture image if this renderbuffer wraps a texture,
3401 * otherwise NULL.
3402 *
3403 * Note that the reference on the gl_texture_object containing this
3404 * TexImage is held by the gl_renderbuffer_attachment.
3405 */
3406 struct gl_texture_image *TexImage;
3407
3408 /** Delete this renderbuffer */
3409 void (*Delete)(struct gl_context *ctx, struct gl_renderbuffer *rb);
3410
3411 /** Allocate new storage for this renderbuffer */
3412 GLboolean (*AllocStorage)(struct gl_context *ctx,
3413 struct gl_renderbuffer *rb,
3414 GLenum internalFormat,
3415 GLuint width, GLuint height);
3416 };
3417
3418
3419 /**
3420 * A renderbuffer attachment points to either a texture object (and specifies
3421 * a mipmap level, cube face or 3D texture slice) or points to a renderbuffer.
3422 */
3423 struct gl_renderbuffer_attachment
3424 {
3425 GLenum16 Type; /**< \c GL_NONE or \c GL_TEXTURE or \c GL_RENDERBUFFER_EXT */
3426 GLboolean Complete;
3427
3428 /**
3429 * If \c Type is \c GL_RENDERBUFFER_EXT, this stores a pointer to the
3430 * application supplied renderbuffer object.
3431 */
3432 struct gl_renderbuffer *Renderbuffer;
3433
3434 /**
3435 * If \c Type is \c GL_TEXTURE, this stores a pointer to the application
3436 * supplied texture object.
3437 */
3438 struct gl_texture_object *Texture;
3439 GLuint TextureLevel; /**< Attached mipmap level. */
3440 GLsizei NumSamples; /**< from FramebufferTexture2DMultisampleEXT */
3441 GLuint CubeMapFace; /**< 0 .. 5, for cube map textures. */
3442 GLuint Zoffset; /**< Slice for 3D textures, or layer for both 1D
3443 * and 2D array textures */
3444 GLboolean Layered;
3445 };
3446
3447
3448 /**
3449 * A framebuffer is a collection of renderbuffers (color, depth, stencil, etc).
3450 * In C++ terms, think of this as a base class from which device drivers
3451 * will make derived classes.
3452 */
3453 struct gl_framebuffer
3454 {
3455 simple_mtx_t Mutex; /**< for thread safety */
3456 /**
3457 * If zero, this is a window system framebuffer. If non-zero, this
3458 * is a FBO framebuffer; note that for some devices (i.e. those with
3459 * a natural pixel coordinate system for FBOs that differs from the
3460 * OpenGL/Mesa coordinate system), this means that the viewport,
3461 * polygon face orientation, and polygon stipple will have to be inverted.
3462 */
3463 GLuint Name;
3464 GLint RefCount;
3465
3466 GLchar *Label; /**< GL_KHR_debug */
3467
3468 GLboolean DeletePending;
3469
3470 /**
3471 * The framebuffer's visual. Immutable if this is a window system buffer.
3472 * Computed from attachments if user-made FBO.
3473 */
3474 struct gl_config Visual;
3475
3476 /**
3477 * Size of frame buffer in pixels. If there are no attachments, then both
3478 * of these are 0.
3479 */
3480 GLuint Width, Height;
3481
3482 /**
3483 * In the case that the framebuffer has no attachment (i.e.
3484 * GL_ARB_framebuffer_no_attachments) then the geometry of
3485 * the framebuffer is specified by the default values.
3486 */
3487 struct {
3488 GLuint Width, Height, Layers, NumSamples;
3489 GLboolean FixedSampleLocations;
3490 /* Derived from NumSamples by the driver so that it can choose a valid
3491 * value for the hardware.
3492 */
3493 GLuint _NumSamples;
3494 } DefaultGeometry;
3495
3496 /** \name Drawing bounds (Intersection of buffer size and scissor box)
3497 * The drawing region is given by [_Xmin, _Xmax) x [_Ymin, _Ymax),
3498 * (inclusive for _Xmin and _Ymin while exclusive for _Xmax and _Ymax)
3499 */
3500 /*@{*/
3501 GLint _Xmin, _Xmax;
3502 GLint _Ymin, _Ymax;
3503 /*@}*/
3504
3505 /** \name Derived Z buffer stuff */
3506 /*@{*/
3507 GLuint _DepthMax; /**< Max depth buffer value */
3508 GLfloat _DepthMaxF; /**< Float max depth buffer value */
3509 GLfloat _MRD; /**< minimum resolvable difference in Z values */
3510 /*@}*/
3511
3512 /** One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */
3513 GLenum16 _Status;
3514
3515 /** Whether one of Attachment has Type != GL_NONE
3516 * NOTE: the values for Width and Height are set to 0 in case of having
3517 * no attachments, a backend driver supporting the extension
3518 * GL_ARB_framebuffer_no_attachments must check for the flag _HasAttachments
3519 * and if GL_FALSE, must then use the values in DefaultGeometry to initialize
3520 * its viewport, scissor and so on (in particular _Xmin, _Xmax, _Ymin and
3521 * _Ymax do NOT take into account _HasAttachments being false). To get the
3522 * geometry of the framebuffer, the helper functions
3523 * _mesa_geometric_width(),
3524 * _mesa_geometric_height(),
3525 * _mesa_geometric_samples() and
3526 * _mesa_geometric_layers()
3527 * are available that check _HasAttachments.
3528 */
3529 bool _HasAttachments;
3530
3531 GLbitfield _IntegerBuffers; /**< Which color buffers are integer valued */
3532 GLbitfield _RGBBuffers; /**< Which color buffers have baseformat == RGB */
3533 GLbitfield _FP32Buffers; /**< Which color buffers are FP32 */
3534
3535 /* ARB_color_buffer_float */
3536 GLboolean _AllColorBuffersFixedPoint; /* no integer, no float */
3537 GLboolean _HasSNormOrFloatColorBuffer;
3538
3539 /**
3540 * The maximum number of layers in the framebuffer, or 0 if the framebuffer
3541 * is not layered. For cube maps and cube map arrays, each cube face
3542 * counts as a layer. As the case for Width, Height a backend driver
3543 * supporting GL_ARB_framebuffer_no_attachments must use DefaultGeometry
3544 * in the case that _HasAttachments is false
3545 */
3546 GLuint MaxNumLayers;
3547
3548 /** Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */
3549 struct gl_renderbuffer_attachment Attachment[BUFFER_COUNT];
3550
3551 /* In unextended OpenGL these vars are part of the GL_COLOR_BUFFER
3552 * attribute group and GL_PIXEL attribute group, respectively.
3553 */
3554 GLenum16 ColorDrawBuffer[MAX_DRAW_BUFFERS];
3555 GLenum16 ColorReadBuffer;
3556
3557 /* GL_ARB_sample_locations */
3558 GLfloat *SampleLocationTable; /**< If NULL, no table has been specified */
3559 GLboolean ProgrammableSampleLocations;
3560 GLboolean SampleLocationPixelGrid;
3561
3562 /** Computed from ColorDraw/ReadBuffer above */
3563 GLuint _NumColorDrawBuffers;
3564 gl_buffer_index _ColorDrawBufferIndexes[MAX_DRAW_BUFFERS];
3565 gl_buffer_index _ColorReadBufferIndex;
3566 struct gl_renderbuffer *_ColorDrawBuffers[MAX_DRAW_BUFFERS];
3567 struct gl_renderbuffer *_ColorReadBuffer;
3568
3569 /* GL_MESA_framebuffer_flip_y */
3570 bool FlipY;
3571
3572 /** Delete this framebuffer */
3573 void (*Delete)(struct gl_framebuffer *fb);
3574 };
3575
3576
3577 /**
3578 * Precision info for shader datatypes. See glGetShaderPrecisionFormat().
3579 */
3580 struct gl_precision
3581 {
3582 GLushort RangeMin; /**< min value exponent */
3583 GLushort RangeMax; /**< max value exponent */
3584 GLushort Precision; /**< number of mantissa bits */
3585 };
3586
3587
3588 /**
3589 * Limits for vertex, geometry and fragment programs/shaders.
3590 */
3591 struct gl_program_constants
3592 {
3593 /* logical limits */
3594 GLuint MaxInstructions;
3595 GLuint MaxAluInstructions;
3596 GLuint MaxTexInstructions;
3597 GLuint MaxTexIndirections;
3598 GLuint MaxAttribs;
3599 GLuint MaxTemps;
3600 GLuint MaxAddressRegs;
3601 GLuint MaxAddressOffset; /**< [-MaxAddressOffset, MaxAddressOffset-1] */
3602 GLuint MaxParameters;
3603 GLuint MaxLocalParams;
3604 GLuint MaxEnvParams;
3605 /* native/hardware limits */
3606 GLuint MaxNativeInstructions;
3607 GLuint MaxNativeAluInstructions;
3608 GLuint MaxNativeTexInstructions;
3609 GLuint MaxNativeTexIndirections;
3610 GLuint MaxNativeAttribs;
3611 GLuint MaxNativeTemps;
3612 GLuint MaxNativeAddressRegs;
3613 GLuint MaxNativeParameters;
3614 /* For shaders */
3615 GLuint MaxUniformComponents; /**< Usually == MaxParameters * 4 */
3616
3617 /**
3618 * \name Per-stage input / output limits
3619 *
3620 * Previous to OpenGL 3.2, the intrastage data limits were advertised with
3621 * a single value: GL_MAX_VARYING_COMPONENTS (GL_MAX_VARYING_VECTORS in
3622 * ES). This is stored as \c gl_constants::MaxVarying.
3623 *
3624 * Starting with OpenGL 3.2, the limits are advertised with per-stage
3625 * variables. Each stage as a certain number of outputs that it can feed
3626 * to the next stage and a certain number inputs that it can consume from
3627 * the previous stage.
3628 *
3629 * Vertex shader inputs do not participate this in this accounting.
3630 * These are tracked exclusively by \c gl_program_constants::MaxAttribs.
3631 *
3632 * Fragment shader outputs do not participate this in this accounting.
3633 * These are tracked exclusively by \c gl_constants::MaxDrawBuffers.
3634 */
3635 /*@{*/
3636 GLuint MaxInputComponents;
3637 GLuint MaxOutputComponents;
3638 /*@}*/
3639
3640 /* ES 2.0 and GL_ARB_ES2_compatibility */
3641 struct gl_precision LowFloat, MediumFloat, HighFloat;
3642 struct gl_precision LowInt, MediumInt, HighInt;
3643 /* GL_ARB_uniform_buffer_object */
3644 GLuint MaxUniformBlocks;
3645 uint64_t MaxCombinedUniformComponents;
3646 GLuint MaxTextureImageUnits;
3647
3648 /* GL_ARB_shader_atomic_counters */
3649 GLuint MaxAtomicBuffers;
3650 GLuint MaxAtomicCounters;
3651
3652 /* GL_ARB_shader_image_load_store */
3653 GLuint MaxImageUniforms;
3654
3655 /* GL_ARB_shader_storage_buffer_object */
3656 GLuint MaxShaderStorageBlocks;
3657 };
3658
3659 /**
3660 * Constants which may be overridden by device driver during context creation
3661 * but are never changed after that.
3662 */
3663 struct gl_constants
3664 {
3665 GLuint MaxTextureMbytes; /**< Max memory per image, in MB */
3666 GLuint MaxTextureSize; /**< Max 1D/2D texture size, in pixels*/
3667 GLuint Max3DTextureLevels; /**< Max mipmap levels for 3D textures */
3668 GLuint MaxCubeTextureLevels; /**< Max mipmap levels for cube textures */
3669 GLuint MaxArrayTextureLayers; /**< Max layers in array textures */
3670 GLuint MaxTextureRectSize; /**< Max rectangle texture size, in pixes */
3671 GLuint MaxTextureCoordUnits;
3672 GLuint MaxCombinedTextureImageUnits;
3673 GLuint MaxTextureUnits; /**< = MIN(CoordUnits, FragmentProgram.ImageUnits) */
3674 GLfloat MaxTextureMaxAnisotropy; /**< GL_EXT_texture_filter_anisotropic */
3675 GLfloat MaxTextureLodBias; /**< GL_EXT_texture_lod_bias */
3676 GLuint MaxTextureBufferSize; /**< GL_ARB_texture_buffer_object */
3677
3678 GLuint TextureBufferOffsetAlignment; /**< GL_ARB_texture_buffer_range */
3679
3680 GLuint MaxArrayLockSize;
3681
3682 GLint SubPixelBits;
3683
3684 GLfloat MinPointSize, MaxPointSize; /**< aliased */
3685 GLfloat MinPointSizeAA, MaxPointSizeAA; /**< antialiased */
3686 GLfloat PointSizeGranularity;
3687 GLfloat MinLineWidth, MaxLineWidth; /**< aliased */
3688 GLfloat MinLineWidthAA, MaxLineWidthAA; /**< antialiased */
3689 GLfloat LineWidthGranularity;
3690
3691 GLuint MaxClipPlanes;
3692 GLuint MaxLights;
3693 GLfloat MaxShininess; /**< GL_NV_light_max_exponent */
3694 GLfloat MaxSpotExponent; /**< GL_NV_light_max_exponent */
3695
3696 GLuint MaxViewportWidth, MaxViewportHeight;
3697 GLuint MaxViewports; /**< GL_ARB_viewport_array */
3698 GLuint ViewportSubpixelBits; /**< GL_ARB_viewport_array */
3699 struct {
3700 GLfloat Min;
3701 GLfloat Max;
3702 } ViewportBounds; /**< GL_ARB_viewport_array */
3703 GLuint MaxWindowRectangles; /**< GL_EXT_window_rectangles */
3704
3705 struct gl_program_constants Program[MESA_SHADER_STAGES];
3706 GLuint MaxProgramMatrices;
3707 GLuint MaxProgramMatrixStackDepth;
3708
3709 struct {
3710 GLuint SamplesPassed;
3711 GLuint TimeElapsed;
3712 GLuint Timestamp;
3713 GLuint PrimitivesGenerated;
3714 GLuint PrimitivesWritten;
3715 GLuint VerticesSubmitted;
3716 GLuint PrimitivesSubmitted;
3717 GLuint VsInvocations;
3718 GLuint TessPatches;
3719 GLuint TessInvocations;
3720 GLuint GsInvocations;
3721 GLuint GsPrimitives;
3722 GLuint FsInvocations;
3723 GLuint ComputeInvocations;
3724 GLuint ClInPrimitives;
3725 GLuint ClOutPrimitives;
3726 } QueryCounterBits;
3727
3728 GLuint MaxDrawBuffers; /**< GL_ARB_draw_buffers */
3729
3730 GLuint MaxColorAttachments; /**< GL_EXT_framebuffer_object */
3731 GLuint MaxRenderbufferSize; /**< GL_EXT_framebuffer_object */
3732 GLuint MaxSamples; /**< GL_ARB_framebuffer_object */
3733
3734 /**
3735 * GL_ARB_framebuffer_no_attachments
3736 */
3737 GLuint MaxFramebufferWidth;
3738 GLuint MaxFramebufferHeight;
3739 GLuint MaxFramebufferLayers;
3740 GLuint MaxFramebufferSamples;
3741
3742 /** Number of varying vectors between any two shader stages. */
3743 GLuint MaxVarying;
3744
3745 /** @{
3746 * GL_ARB_uniform_buffer_object
3747 */
3748 GLuint MaxCombinedUniformBlocks;
3749 GLuint MaxUniformBufferBindings;
3750 GLuint MaxUniformBlockSize;
3751 GLuint UniformBufferOffsetAlignment;
3752 /** @} */
3753
3754 /** @{
3755 * GL_ARB_shader_storage_buffer_object
3756 */
3757 GLuint MaxCombinedShaderStorageBlocks;
3758 GLuint MaxShaderStorageBufferBindings;
3759 GLuint MaxShaderStorageBlockSize;
3760 GLuint ShaderStorageBufferOffsetAlignment;
3761 /** @} */
3762
3763 /**
3764 * GL_ARB_explicit_uniform_location
3765 */
3766 GLuint MaxUserAssignableUniformLocations;
3767
3768 /** geometry shader */
3769 GLuint MaxGeometryOutputVertices;
3770 GLuint MaxGeometryTotalOutputComponents;
3771 GLuint MaxGeometryShaderInvocations;
3772
3773 GLuint GLSLVersion; /**< Desktop GLSL version supported (ex: 120 = 1.20) */
3774 GLuint GLSLVersionCompat; /**< Desktop compat GLSL version supported */
3775
3776 /**
3777 * Changes default GLSL extension behavior from "error" to "warn". It's out
3778 * of spec, but it can make some apps work that otherwise wouldn't.
3779 */
3780 GLboolean ForceGLSLExtensionsWarn;
3781
3782 /**
3783 * If non-zero, forces GLSL shaders to behave as if they began
3784 * with "#version ForceGLSLVersion".
3785 */
3786 GLuint ForceGLSLVersion;
3787
3788 /**
3789 * Allow GLSL #extension directives in the middle of shaders.
3790 */
3791 GLboolean AllowGLSLExtensionDirectiveMidShader;
3792
3793 /**
3794 * Allow builtins as part of constant expressions. This was not allowed
3795 * until GLSL 1.20 this allows it everywhere.
3796 */
3797 GLboolean AllowGLSLBuiltinConstantExpression;
3798
3799 /**
3800 * Allow some relaxation of GLSL ES shader restrictions. This encompasses
3801 * a number of relaxations to the ES shader rules.
3802 */
3803 GLboolean AllowGLSLRelaxedES;
3804
3805 /**
3806 * Allow GLSL built-in variables to be redeclared verbatim
3807 */
3808 GLboolean AllowGLSLBuiltinVariableRedeclaration;
3809
3810 /**
3811 * Allow GLSL interpolation qualifier mismatch across shader stages.
3812 */
3813 GLboolean AllowGLSLCrossStageInterpolationMismatch;
3814
3815 /**
3816 * Allow creating a higher compat profile (version 3.1+) for apps that
3817 * request it. Be careful when adding that driconf option because some
3818 * features are unimplemented and might not work correctly.
3819 */
3820 GLboolean AllowHigherCompatVersion;
3821
3822 /**
3823 * Allow layout qualifiers on function parameters.
3824 */
3825 GLboolean AllowLayoutQualifiersOnFunctionParameters;
3826
3827 /**
3828 * Force computing the absolute value for sqrt() and inversesqrt() to follow
3829 * D3D9 when apps rely on this behaviour.
3830 */
3831 GLboolean ForceGLSLAbsSqrt;
3832
3833 /**
3834 * Force uninitialized variables to default to zero.
3835 */
3836 GLboolean GLSLZeroInit;
3837
3838 /**
3839 * Does the driver support real 32-bit integers? (Otherwise, integers are
3840 * simulated via floats.)
3841 */
3842 GLboolean NativeIntegers;
3843
3844 /**
3845 * Does VertexID count from zero or from base vertex?
3846 *
3847 * \note
3848 * If desktop GLSL 1.30 or GLSL ES 3.00 are not supported, this field is
3849 * ignored and need not be set.
3850 */
3851 bool VertexID_is_zero_based;
3852
3853 /**
3854 * If the driver supports real 32-bit integers, what integer value should be
3855 * used for boolean true in unifo