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