Rev 1901 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1901 | serge | 1 | /* |
2 | * Mesa 3-D graphics library |
||
3 | * Version: 7.3 |
||
4 | * |
||
5 | * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. |
||
6 | * Copyright (C) 2008 VMware, Inc. All Rights Reserved. |
||
7 | * |
||
8 | * Permission is hereby granted, free of charge, to any person obtaining a |
||
9 | * copy of this software and associated documentation files (the "Software"), |
||
10 | * to deal in the Software without restriction, including without limitation |
||
11 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||
12 | * and/or sell copies of the Software, and to permit persons to whom the |
||
13 | * Software is furnished to do so, subject to the following conditions: |
||
14 | * |
||
15 | * The above copyright notice and this permission notice shall be included |
||
16 | * in all copies or substantial portions of the Software. |
||
17 | * |
||
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
||
19 | * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||
20 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||
21 | * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN |
||
22 | * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
||
23 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
||
24 | */ |
||
25 | |||
26 | /** |
||
27 | * \file context.c |
||
28 | * Mesa context/visual/framebuffer management functions. |
||
29 | * \author Brian Paul |
||
30 | */ |
||
31 | |||
32 | /** |
||
33 | * \mainpage Mesa Main Module |
||
34 | * |
||
35 | * \section MainIntroduction Introduction |
||
36 | * |
||
37 | * The Mesa Main module consists of all the files in the main/ directory. |
||
38 | * Among the features of this module are: |
||
39 | * |
||
40 | * |
||
41 | * |
||
42 | * |
||
43 | * |
||
44 | * |
||
45 | * |
||
46 | * |
||
47 | * Other modules are responsible for API dispatch, vertex transformation, |
||
48 | * point/line/triangle setup, rasterization, vertex array caching, |
||
49 | * vertex/fragment programs/shaders, etc. |
||
50 | * |
||
51 | * |
||
52 | * \section AboutDoxygen About Doxygen |
||
53 | * |
||
54 | * If you're viewing this information as Doxygen-generated HTML you'll |
||
55 | * see the documentation index at the top of this page. |
||
56 | * |
||
57 | * The first line lists the Mesa source code modules. |
||
58 | * The second line lists the indexes available for viewing the documentation |
||
59 | * for each module. |
||
60 | * |
||
61 | * Selecting the Main page link will display a summary of the module |
||
62 | * (this page). |
||
63 | * |
||
64 | * Selecting Data Structures will list all C structures. |
||
65 | * |
||
66 | * Selecting the File List link will list all the source files in |
||
67 | * the module. |
||
68 | * Selecting a filename will show a list of all functions defined in that file. |
||
69 | * |
||
70 | * Selecting the Data Fields link will display a list of all |
||
71 | * documented structure members. |
||
72 | * |
||
73 | * Selecting the Globals link will display a list |
||
74 | * of all functions, structures, global variables and macros in the module. |
||
75 | * |
||
76 | */ |
||
77 | |||
78 | |||
79 | #include "glheader.h" |
||
80 | #include "mfeatures.h" |
||
81 | #include "imports.h" |
||
82 | #include "accum.h" |
||
83 | #include "api_exec.h" |
||
84 | #include "arrayobj.h" |
||
85 | #include "attrib.h" |
||
86 | #include "blend.h" |
||
87 | #include "buffers.h" |
||
88 | #include "bufferobj.h" |
||
89 | #include "context.h" |
||
90 | #include "cpuinfo.h" |
||
91 | #include "debug.h" |
||
92 | #include "depth.h" |
||
93 | #include "dlist.h" |
||
94 | #include "eval.h" |
||
95 | #include "extensions.h" |
||
96 | #include "fbobject.h" |
||
97 | #include "feedback.h" |
||
98 | #include "fog.h" |
||
99 | #include "framebuffer.h" |
||
100 | #include "hint.h" |
||
101 | #include "hash.h" |
||
102 | #include "light.h" |
||
103 | #include "lines.h" |
||
104 | #include "macros.h" |
||
105 | #include "matrix.h" |
||
106 | #include "multisample.h" |
||
107 | #include "pixel.h" |
||
108 | #include "pixelstore.h" |
||
109 | #include "points.h" |
||
110 | #include "polygon.h" |
||
111 | #include "queryobj.h" |
||
112 | #include "syncobj.h" |
||
113 | #include "rastpos.h" |
||
114 | #include "remap.h" |
||
115 | #include "scissor.h" |
||
116 | #include "shared.h" |
||
117 | #include "shaderobj.h" |
||
118 | #include "simple_list.h" |
||
119 | #include "state.h" |
||
120 | #include "stencil.h" |
||
121 | #include "texcompress_s3tc.h" |
||
122 | #include "texstate.h" |
||
123 | #include "transformfeedback.h" |
||
124 | #include "mtypes.h" |
||
125 | #include "varray.h" |
||
126 | #include "version.h" |
||
127 | #include "viewport.h" |
||
128 | #include "vtxfmt.h" |
||
129 | #include "program/program.h" |
||
130 | #include "program/prog_print.h" |
||
131 | #if _HAVE_FULL_GL |
||
132 | #include "math/m_matrix.h" |
||
133 | #endif |
||
134 | #include "main/dispatch.h" /* for _gloffset_COUNT */ |
||
135 | |||
136 | #ifdef USE_SPARC_ASM |
||
137 | #include "sparc/sparc.h" |
||
138 | #endif |
||
139 | |||
140 | #include "glsl_parser_extras.h" |
||
141 | #include |
||
142 | |||
143 | |||
144 | #ifndef MESA_VERBOSE |
||
145 | int MESA_VERBOSE = 0; |
||
146 | #endif |
||
147 | |||
148 | #ifndef MESA_DEBUG_FLAGS |
||
149 | int MESA_DEBUG_FLAGS = 0; |
||
150 | #endif |
||
151 | |||
152 | |||
153 | /* ubyte -> float conversion */ |
||
154 | GLfloat _mesa_ubyte_to_float_color_tab[256]; |
||
155 | |||
156 | |||
157 | |||
158 | /** |
||
159 | * Swap buffers notification callback. |
||
160 | * |
||
161 | * \param ctx GL context. |
||
162 | * |
||
163 | * Called by window system just before swapping buffers. |
||
164 | * We have to finish any pending rendering. |
||
165 | */ |
||
166 | void |
||
167 | _mesa_notifySwapBuffers(struct gl_context *ctx) |
||
168 | { |
||
169 | if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS) |
||
170 | _mesa_debug(ctx, "SwapBuffers\n"); |
||
171 | FLUSH_CURRENT( ctx, 0 ); |
||
172 | if (ctx->Driver.Flush) { |
||
173 | ctx->Driver.Flush(ctx); |
||
174 | } |
||
175 | } |
||
176 | |||
177 | |||
178 | /**********************************************************************/ |
||
179 | /** \name GL Visual allocation/destruction */ |
||
180 | /**********************************************************************/ |
||
181 | /*@{*/ |
||
182 | |||
183 | /** |
||
184 | * Allocates a struct gl_config structure and initializes it via |
||
185 | * _mesa_initialize_visual(). |
||
186 | * |
||
187 | * \param dbFlag double buffering |
||
188 | * \param stereoFlag stereo buffer |
||
189 | * \param depthBits requested bits per depth buffer value. Any value in [0, 32] |
||
190 | * is acceptable but the actual depth type will be GLushort or GLuint as |
||
191 | * needed. |
||
192 | * \param stencilBits requested minimum bits per stencil buffer value |
||
193 | * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer. |
||
194 | * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE |
||
195 | * \param redBits number of bits per color component in frame buffer for RGB(A) |
||
196 | * mode. We always use 8 in core Mesa though. |
||
197 | * \param greenBits same as above. |
||
198 | * \param blueBits same as above. |
||
199 | * \param alphaBits same as above. |
||
200 | * \param numSamples not really used. |
||
201 | * |
||
202 | * \return pointer to new struct gl_config or NULL if requested parameters can't be |
||
203 | * met. |
||
204 | * |
||
205 | * \note Need to add params for level and numAuxBuffers (at least) |
||
206 | */ |
||
207 | struct gl_config * |
||
208 | _mesa_create_visual( GLboolean dbFlag, |
||
209 | GLboolean stereoFlag, |
||
210 | GLint redBits, |
||
211 | GLint greenBits, |
||
212 | GLint blueBits, |
||
213 | GLint alphaBits, |
||
214 | GLint depthBits, |
||
215 | GLint stencilBits, |
||
216 | GLint accumRedBits, |
||
217 | GLint accumGreenBits, |
||
218 | GLint accumBlueBits, |
||
219 | GLint accumAlphaBits, |
||
220 | GLint numSamples ) |
||
221 | { |
||
222 | struct gl_config *vis = CALLOC_STRUCT(gl_config); |
||
223 | if (vis) { |
||
224 | if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag, |
||
225 | redBits, greenBits, blueBits, alphaBits, |
||
226 | depthBits, stencilBits, |
||
227 | accumRedBits, accumGreenBits, |
||
228 | accumBlueBits, accumAlphaBits, |
||
229 | numSamples)) { |
||
230 | free(vis); |
||
231 | return NULL; |
||
232 | } |
||
233 | } |
||
234 | return vis; |
||
235 | } |
||
236 | |||
237 | |||
238 | /** |
||
239 | * Makes some sanity checks and fills in the fields of the struct |
||
240 | * gl_config object with the given parameters. If the caller needs to |
||
241 | * set additional fields, he should just probably init the whole |
||
242 | * gl_config object himself. |
||
243 | * |
||
244 | * \return GL_TRUE on success, or GL_FALSE on failure. |
||
245 | * |
||
246 | * \sa _mesa_create_visual() above for the parameter description. |
||
247 | */ |
||
248 | GLboolean |
||
249 | _mesa_initialize_visual( struct gl_config *vis, |
||
250 | GLboolean dbFlag, |
||
251 | GLboolean stereoFlag, |
||
252 | GLint redBits, |
||
253 | GLint greenBits, |
||
254 | GLint blueBits, |
||
255 | GLint alphaBits, |
||
256 | GLint depthBits, |
||
257 | GLint stencilBits, |
||
258 | GLint accumRedBits, |
||
259 | GLint accumGreenBits, |
||
260 | GLint accumBlueBits, |
||
261 | GLint accumAlphaBits, |
||
262 | GLint numSamples ) |
||
263 | { |
||
264 | assert(vis); |
||
265 | |||
266 | if (depthBits < 0 || depthBits > 32) { |
||
267 | return GL_FALSE; |
||
268 | } |
||
269 | if (stencilBits < 0 || stencilBits > STENCIL_BITS) { |
||
270 | return GL_FALSE; |
||
271 | } |
||
272 | assert(accumRedBits >= 0); |
||
273 | assert(accumGreenBits >= 0); |
||
274 | assert(accumBlueBits >= 0); |
||
275 | assert(accumAlphaBits >= 0); |
||
276 | |||
277 | vis->rgbMode = GL_TRUE; |
||
278 | vis->doubleBufferMode = dbFlag; |
||
279 | vis->stereoMode = stereoFlag; |
||
280 | |||
281 | vis->redBits = redBits; |
||
282 | vis->greenBits = greenBits; |
||
283 | vis->blueBits = blueBits; |
||
284 | vis->alphaBits = alphaBits; |
||
285 | vis->rgbBits = redBits + greenBits + blueBits; |
||
286 | |||
287 | vis->indexBits = 0; |
||
288 | vis->depthBits = depthBits; |
||
289 | vis->stencilBits = stencilBits; |
||
290 | |||
291 | vis->accumRedBits = accumRedBits; |
||
292 | vis->accumGreenBits = accumGreenBits; |
||
293 | vis->accumBlueBits = accumBlueBits; |
||
294 | vis->accumAlphaBits = accumAlphaBits; |
||
295 | |||
296 | vis->haveAccumBuffer = accumRedBits > 0; |
||
297 | vis->haveDepthBuffer = depthBits > 0; |
||
298 | vis->haveStencilBuffer = stencilBits > 0; |
||
299 | |||
300 | vis->numAuxBuffers = 0; |
||
301 | vis->level = 0; |
||
302 | vis->sampleBuffers = numSamples > 0 ? 1 : 0; |
||
303 | vis->samples = numSamples; |
||
304 | |||
305 | return GL_TRUE; |
||
306 | } |
||
307 | |||
308 | |||
309 | /** |
||
310 | * Destroy a visual and free its memory. |
||
311 | * |
||
312 | * \param vis visual. |
||
313 | * |
||
314 | * Frees the visual structure. |
||
315 | */ |
||
316 | void |
||
317 | _mesa_destroy_visual( struct gl_config *vis ) |
||
318 | { |
||
319 | free(vis); |
||
320 | } |
||
321 | |||
322 | /*@}*/ |
||
323 | |||
324 | |||
325 | /**********************************************************************/ |
||
326 | /** \name Context allocation, initialization, destroying |
||
327 | * |
||
328 | * The purpose of the most initialization functions here is to provide the |
||
329 | * default state values according to the OpenGL specification. |
||
330 | */ |
||
331 | /**********************************************************************/ |
||
332 | /*@{*/ |
||
333 | |||
334 | |||
335 | /** |
||
336 | * This is lame. gdb only seems to recognize enum types that are |
||
337 | * actually used somewhere. We want to be able to print/use enum |
||
338 | * values such as TEXTURE_2D_INDEX in gdb. But we don't actually use |
||
339 | * the gl_texture_index type anywhere. Thus, this lame function. |
||
340 | */ |
||
341 | static void |
||
342 | dummy_enum_func(void) |
||
343 | { |
||
344 | gl_buffer_index bi = BUFFER_FRONT_LEFT; |
||
345 | gl_face_index fi = FACE_POS_X; |
||
346 | gl_frag_attrib fa = FRAG_ATTRIB_WPOS; |
||
347 | gl_frag_result fr = FRAG_RESULT_DEPTH; |
||
348 | gl_texture_index ti = TEXTURE_2D_ARRAY_INDEX; |
||
349 | gl_vert_attrib va = VERT_ATTRIB_POS; |
||
350 | gl_vert_result vr = VERT_RESULT_HPOS; |
||
351 | gl_geom_attrib ga = GEOM_ATTRIB_POSITION; |
||
352 | gl_geom_result gr = GEOM_RESULT_POS; |
||
353 | |||
354 | (void) bi; |
||
355 | (void) fi; |
||
356 | (void) fa; |
||
357 | (void) fr; |
||
358 | (void) ti; |
||
359 | (void) va; |
||
360 | (void) vr; |
||
361 | (void) ga; |
||
362 | (void) gr; |
||
363 | } |
||
364 | |||
365 | |||
366 | /** |
||
367 | * One-time initialization mutex lock. |
||
368 | * |
||
369 | * \sa Used by one_time_init(). |
||
370 | */ |
||
371 | _glthread_DECLARE_STATIC_MUTEX(OneTimeLock); |
||
372 | |||
373 | |||
374 | |||
375 | /** |
||
376 | * Calls all the various one-time-init functions in Mesa. |
||
377 | * |
||
378 | * While holding a global mutex lock, calls several initialization functions, |
||
379 | * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is |
||
380 | * defined. |
||
381 | * |
||
382 | * \sa _math_init(). |
||
383 | */ |
||
384 | static void |
||
385 | one_time_init( struct gl_context *ctx ) |
||
386 | { |
||
387 | static GLbitfield api_init_mask = 0x0; |
||
388 | |||
389 | _glthread_LOCK_MUTEX(OneTimeLock); |
||
390 | |||
391 | /* truly one-time init */ |
||
392 | if (!api_init_mask) { |
||
393 | GLuint i; |
||
394 | |||
395 | /* do some implementation tests */ |
||
396 | assert( sizeof(GLbyte) == 1 ); |
||
397 | assert( sizeof(GLubyte) == 1 ); |
||
398 | assert( sizeof(GLshort) == 2 ); |
||
399 | assert( sizeof(GLushort) == 2 ); |
||
400 | assert( sizeof(GLint) == 4 ); |
||
401 | assert( sizeof(GLuint) == 4 ); |
||
402 | |||
403 | _mesa_get_cpu_features(); |
||
404 | |||
405 | _mesa_init_sqrt_table(); |
||
406 | |||
407 | /* context dependence is never a one-time thing... */ |
||
408 | _mesa_init_get_hash(ctx); |
||
409 | |||
410 | for (i = 0; i < 256; i++) { |
||
411 | _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F; |
||
412 | } |
||
413 | |||
414 | #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__) |
||
415 | if (MESA_VERBOSE != 0) { |
||
416 | _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n", |
||
417 | MESA_VERSION_STRING, __DATE__, __TIME__); |
||
418 | } |
||
419 | #endif |
||
420 | } |
||
421 | |||
422 | /* per-API one-time init */ |
||
423 | if (!(api_init_mask & (1 << ctx->API))) { |
||
424 | /* |
||
425 | * This is fine as ES does not use the remap table, but it may not be |
||
426 | * future-proof. We cannot always initialize the remap table because |
||
427 | * when an app is linked to libGLES*, there are not enough dynamic |
||
428 | * entries. |
||
429 | */ |
||
430 | if (ctx->API == API_OPENGL) |
||
431 | _mesa_init_remap_table(); |
||
432 | } |
||
433 | |||
434 | api_init_mask |= 1 << ctx->API; |
||
435 | |||
436 | _glthread_UNLOCK_MUTEX(OneTimeLock); |
||
437 | |||
438 | /* Hopefully atexit() is widely available. If not, we may need some |
||
439 | * #ifdef tests here. |
||
440 | */ |
||
1907 | serge | 441 | atexit(_mesa_destroy_shader_compiler); |
1901 | serge | 442 | |
443 | dummy_enum_func(); |
||
444 | } |
||
445 | |||
446 | |||
447 | /** |
||
448 | * Initialize fields of gl_current_attrib (aka ctx->Current.*) |
||
449 | */ |
||
450 | static void |
||
451 | _mesa_init_current(struct gl_context *ctx) |
||
452 | { |
||
453 | GLuint i; |
||
454 | |||
455 | /* Init all to (0,0,0,1) */ |
||
456 | for (i = 0; i < Elements(ctx->Current.Attrib); i++) { |
||
457 | ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 ); |
||
458 | } |
||
459 | |||
460 | /* redo special cases: */ |
||
461 | ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 ); |
||
462 | ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 ); |
||
463 | ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 ); |
||
464 | ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 ); |
||
465 | ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 ); |
||
466 | ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 ); |
||
467 | } |
||
468 | |||
469 | |||
470 | /** |
||
471 | * Init vertex/fragment/geometry program limits. |
||
472 | * Important: drivers should override these with actual limits. |
||
473 | */ |
||
474 | static void |
||
475 | init_program_limits(GLenum type, struct gl_program_constants *prog) |
||
476 | { |
||
477 | prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS; |
||
478 | prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS; |
||
479 | prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS; |
||
480 | prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS; |
||
481 | prog->MaxTemps = MAX_PROGRAM_TEMPS; |
||
482 | prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS; |
||
483 | prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS; |
||
484 | prog->MaxUniformComponents = 4 * MAX_UNIFORMS; |
||
485 | |||
486 | switch (type) { |
||
487 | case GL_VERTEX_PROGRAM_ARB: |
||
488 | prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS; |
||
489 | prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS; |
||
490 | prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS; |
||
491 | break; |
||
492 | case GL_FRAGMENT_PROGRAM_ARB: |
||
493 | prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS; |
||
494 | prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS; |
||
495 | prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS; |
||
496 | break; |
||
497 | case MESA_GEOMETRY_PROGRAM: |
||
498 | prog->MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS; |
||
499 | prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS; |
||
500 | prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS; |
||
501 | |||
502 | prog->MaxGeometryTextureImageUnits = MAX_GEOMETRY_TEXTURE_IMAGE_UNITS; |
||
503 | prog->MaxGeometryVaryingComponents = MAX_GEOMETRY_VARYING_COMPONENTS; |
||
504 | prog->MaxVertexVaryingComponents = MAX_VERTEX_VARYING_COMPONENTS; |
||
505 | prog->MaxGeometryUniformComponents = MAX_GEOMETRY_UNIFORM_COMPONENTS; |
||
506 | prog->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES; |
||
507 | prog->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS; |
||
508 | break; |
||
509 | default: |
||
510 | assert(0 && "Bad program type in init_program_limits()"); |
||
511 | } |
||
512 | |||
513 | /* Set the native limits to zero. This implies that there is no native |
||
514 | * support for shaders. Let the drivers fill in the actual values. |
||
515 | */ |
||
516 | prog->MaxNativeInstructions = 0; |
||
517 | prog->MaxNativeAluInstructions = 0; |
||
518 | prog->MaxNativeTexInstructions = 0; |
||
519 | prog->MaxNativeTexIndirections = 0; |
||
520 | prog->MaxNativeAttribs = 0; |
||
521 | prog->MaxNativeTemps = 0; |
||
522 | prog->MaxNativeAddressRegs = 0; |
||
523 | prog->MaxNativeParameters = 0; |
||
524 | |||
525 | /* Set GLSL datatype range/precision info assuming IEEE float values. |
||
526 | * Drivers should override these defaults as needed. |
||
527 | */ |
||
528 | prog->MediumFloat.RangeMin = 127; |
||
529 | prog->MediumFloat.RangeMax = 127; |
||
530 | prog->MediumFloat.Precision = 23; |
||
531 | prog->LowFloat = prog->HighFloat = prog->MediumFloat; |
||
532 | /* assume ints are stored as floats for now */ |
||
533 | prog->LowInt = prog->MediumInt = prog->HighInt = prog->MediumFloat; |
||
534 | } |
||
535 | |||
536 | |||
537 | /** |
||
538 | * Initialize fields of gl_constants (aka ctx->Const.*). |
||
539 | * Use defaults from config.h. The device drivers will often override |
||
540 | * some of these values (such as number of texture units). |
||
541 | */ |
||
542 | static void |
||
543 | _mesa_init_constants(struct gl_context *ctx) |
||
544 | { |
||
545 | assert(ctx); |
||
546 | |||
547 | /* Constants, may be overriden (usually only reduced) by device drivers */ |
||
548 | ctx->Const.MaxTextureMbytes = MAX_TEXTURE_MBYTES; |
||
549 | ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS; |
||
550 | ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS; |
||
551 | ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS; |
||
552 | ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE; |
||
553 | ctx->Const.MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS; |
||
554 | ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS; |
||
555 | ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS; |
||
556 | ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits, |
||
557 | ctx->Const.MaxTextureImageUnits); |
||
558 | ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY; |
||
559 | ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS; |
||
560 | ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE; |
||
561 | ctx->Const.SubPixelBits = SUB_PIXEL_BITS; |
||
562 | ctx->Const.MinPointSize = MIN_POINT_SIZE; |
||
563 | ctx->Const.MaxPointSize = MAX_POINT_SIZE; |
||
564 | ctx->Const.MinPointSizeAA = MIN_POINT_SIZE; |
||
565 | ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE; |
||
566 | ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY; |
||
567 | ctx->Const.MinLineWidth = MIN_LINE_WIDTH; |
||
568 | ctx->Const.MaxLineWidth = MAX_LINE_WIDTH; |
||
569 | ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH; |
||
570 | ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH; |
||
571 | ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY; |
||
572 | ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE; |
||
573 | ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES; |
||
574 | ctx->Const.MaxLights = MAX_LIGHTS; |
||
575 | ctx->Const.MaxShininess = 128.0; |
||
576 | ctx->Const.MaxSpotExponent = 128.0; |
||
577 | ctx->Const.MaxViewportWidth = MAX_WIDTH; |
||
578 | ctx->Const.MaxViewportHeight = MAX_HEIGHT; |
||
579 | #if FEATURE_ARB_vertex_program |
||
580 | init_program_limits(GL_VERTEX_PROGRAM_ARB, &ctx->Const.VertexProgram); |
||
581 | #endif |
||
582 | #if FEATURE_ARB_fragment_program |
||
583 | init_program_limits(GL_FRAGMENT_PROGRAM_ARB, &ctx->Const.FragmentProgram); |
||
584 | #endif |
||
585 | #if FEATURE_ARB_geometry_shader4 |
||
586 | init_program_limits(MESA_GEOMETRY_PROGRAM, &ctx->Const.GeometryProgram); |
||
587 | #endif |
||
588 | ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES; |
||
589 | ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH; |
||
590 | |||
591 | /* CheckArrayBounds is overriden by drivers/x11 for X server */ |
||
592 | ctx->Const.CheckArrayBounds = GL_FALSE; |
||
593 | |||
594 | /* GL_ARB_draw_buffers */ |
||
595 | ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS; |
||
596 | |||
597 | #if FEATURE_EXT_framebuffer_object |
||
598 | ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS; |
||
599 | ctx->Const.MaxRenderbufferSize = MAX_WIDTH; |
||
600 | #endif |
||
601 | |||
602 | #if FEATURE_ARB_vertex_shader |
||
603 | ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS; |
||
604 | ctx->Const.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS; |
||
605 | ctx->Const.MaxVarying = MAX_VARYING; |
||
606 | #endif |
||
607 | |||
608 | /* Shading language version */ |
||
609 | if (ctx->API == API_OPENGL) { |
||
610 | ctx->Const.GLSLVersion = 120; |
||
611 | } |
||
612 | else if (ctx->API == API_OPENGLES2) { |
||
613 | ctx->Const.GLSLVersion = 100; |
||
614 | } |
||
615 | else if (ctx->API == API_OPENGLES) { |
||
616 | ctx->Const.GLSLVersion = 0; /* GLSL not supported */ |
||
617 | } |
||
618 | |||
619 | /* GL_ARB_framebuffer_object */ |
||
620 | ctx->Const.MaxSamples = 0; |
||
621 | |||
622 | /* GL_ARB_sync */ |
||
623 | ctx->Const.MaxServerWaitTimeout = (GLuint64) ~0; |
||
624 | |||
625 | /* GL_ATI_envmap_bumpmap */ |
||
626 | ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS; |
||
627 | |||
628 | /* GL_EXT_provoking_vertex */ |
||
629 | ctx->Const.QuadsFollowProvokingVertexConvention = GL_TRUE; |
||
630 | |||
631 | /* GL_EXT_transform_feedback */ |
||
632 | ctx->Const.MaxTransformFeedbackSeparateAttribs = MAX_FEEDBACK_ATTRIBS; |
||
633 | ctx->Const.MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS; |
||
634 | ctx->Const.MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS; |
||
635 | |||
636 | /* GL 3.2: hard-coded for now: */ |
||
637 | ctx->Const.ProfileMask = GL_CONTEXT_COMPATIBILITY_PROFILE_BIT; |
||
638 | |||
639 | /** GL_EXT_gpu_shader4 */ |
||
640 | ctx->Const.MinProgramTexelOffset = -8; |
||
641 | ctx->Const.MaxProgramTexelOffset = 7; |
||
642 | } |
||
643 | |||
644 | |||
645 | /** |
||
646 | * Do some sanity checks on the limits/constants for the given context. |
||
647 | * Only called the first time a context is bound. |
||
648 | */ |
||
649 | static void |
||
650 | check_context_limits(struct gl_context *ctx) |
||
651 | { |
||
652 | /* check that we don't exceed the size of various bitfields */ |
||
653 | assert(VERT_RESULT_MAX <= |
||
654 | (8 * sizeof(ctx->VertexProgram._Current->Base.OutputsWritten))); |
||
655 | assert(FRAG_ATTRIB_MAX <= |
||
656 | (8 * sizeof(ctx->FragmentProgram._Current->Base.InputsRead))); |
||
657 | |||
658 | assert(MAX_COMBINED_TEXTURE_IMAGE_UNITS <= 8 * sizeof(GLbitfield)); |
||
659 | |||
660 | /* shader-related checks */ |
||
661 | assert(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS); |
||
662 | assert(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS); |
||
663 | |||
664 | assert(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS); |
||
665 | assert(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS); |
||
666 | assert(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX); |
||
667 | assert(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX); |
||
668 | |||
669 | /* Texture unit checks */ |
||
670 | assert(ctx->Const.MaxTextureImageUnits > 0); |
||
671 | assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS); |
||
672 | assert(ctx->Const.MaxTextureCoordUnits > 0); |
||
673 | assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS); |
||
674 | assert(ctx->Const.MaxTextureUnits > 0); |
||
675 | assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS); |
||
676 | assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS); |
||
677 | assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits, |
||
678 | ctx->Const.MaxTextureCoordUnits)); |
||
679 | assert(ctx->Const.MaxCombinedTextureImageUnits > 0); |
||
680 | assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS); |
||
681 | assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS); |
||
682 | /* number of coord units cannot be greater than number of image units */ |
||
683 | assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits); |
||
684 | |||
685 | |||
686 | /* Texture size checks */ |
||
687 | assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS); |
||
688 | assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS); |
||
689 | assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS); |
||
690 | assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE); |
||
691 | |||
692 | /* make sure largest texture image is <= MAX_WIDTH in size */ |
||
693 | assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= MAX_WIDTH); |
||
694 | assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= MAX_WIDTH); |
||
695 | assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= MAX_WIDTH); |
||
696 | |||
697 | /* Texture level checks */ |
||
698 | assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS); |
||
699 | assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS); |
||
700 | |||
701 | /* Max texture size should be <= max viewport size (render to texture) */ |
||
702 | assert((1 << (MAX_TEXTURE_LEVELS - 1)) <= MAX_WIDTH); |
||
703 | |||
704 | assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH); |
||
705 | assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH); |
||
706 | |||
707 | assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS); |
||
708 | |||
709 | /* if this fails, add more enum values to gl_buffer_index */ |
||
710 | assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT); |
||
711 | |||
712 | /* XXX probably add more tests */ |
||
713 | } |
||
714 | |||
715 | |||
716 | /** |
||
717 | * Initialize the attribute groups in a GL context. |
||
718 | * |
||
719 | * \param ctx GL context. |
||
720 | * |
||
721 | * Initializes all the attributes, calling the respective init* |
||
722 | * functions for the more complex data structures. |
||
723 | */ |
||
724 | static GLboolean |
||
725 | init_attrib_groups(struct gl_context *ctx) |
||
726 | { |
||
727 | assert(ctx); |
||
728 | |||
729 | /* Constants */ |
||
730 | _mesa_init_constants( ctx ); |
||
731 | |||
732 | /* Extensions */ |
||
733 | _mesa_init_extensions( ctx ); |
||
734 | |||
735 | /* Attribute Groups */ |
||
736 | _mesa_init_accum( ctx ); |
||
737 | _mesa_init_attrib( ctx ); |
||
738 | _mesa_init_buffer_objects( ctx ); |
||
739 | _mesa_init_color( ctx ); |
||
740 | _mesa_init_current( ctx ); |
||
741 | _mesa_init_depth( ctx ); |
||
742 | _mesa_init_debug( ctx ); |
||
743 | _mesa_init_display_list( ctx ); |
||
744 | _mesa_init_eval( ctx ); |
||
745 | _mesa_init_fbobjects( ctx ); |
||
746 | _mesa_init_feedback( ctx ); |
||
747 | _mesa_init_fog( ctx ); |
||
748 | _mesa_init_hint( ctx ); |
||
749 | _mesa_init_line( ctx ); |
||
750 | _mesa_init_lighting( ctx ); |
||
751 | _mesa_init_matrix( ctx ); |
||
752 | _mesa_init_multisample( ctx ); |
||
753 | _mesa_init_pixel( ctx ); |
||
754 | _mesa_init_pixelstore( ctx ); |
||
755 | _mesa_init_point( ctx ); |
||
756 | _mesa_init_polygon( ctx ); |
||
757 | _mesa_init_program( ctx ); |
||
758 | _mesa_init_queryobj( ctx ); |
||
759 | _mesa_init_sync( ctx ); |
||
760 | _mesa_init_rastpos( ctx ); |
||
761 | _mesa_init_scissor( ctx ); |
||
762 | _mesa_init_shader_state( ctx ); |
||
763 | _mesa_init_stencil( ctx ); |
||
764 | _mesa_init_transform( ctx ); |
||
765 | _mesa_init_transform_feedback( ctx ); |
||
766 | _mesa_init_varray( ctx ); |
||
767 | _mesa_init_viewport( ctx ); |
||
768 | |||
769 | if (!_mesa_init_texture( ctx )) |
||
770 | return GL_FALSE; |
||
771 | |||
772 | _mesa_init_texture_s3tc( ctx ); |
||
773 | |||
774 | /* Miscellaneous */ |
||
775 | ctx->NewState = _NEW_ALL; |
||
776 | ctx->ErrorValue = (GLenum) GL_NO_ERROR; |
||
777 | ctx->varying_vp_inputs = ~0; |
||
778 | |||
779 | return GL_TRUE; |
||
780 | } |
||
781 | |||
782 | |||
783 | /** |
||
784 | * Update default objects in a GL context with respect to shared state. |
||
785 | * |
||
786 | * \param ctx GL context. |
||
787 | * |
||
788 | * Removes references to old default objects, (texture objects, program |
||
789 | * objects, etc.) and changes to reference those from the current shared |
||
790 | * state. |
||
791 | */ |
||
792 | static GLboolean |
||
793 | update_default_objects(struct gl_context *ctx) |
||
794 | { |
||
795 | assert(ctx); |
||
796 | |||
797 | _mesa_update_default_objects_program(ctx); |
||
798 | _mesa_update_default_objects_texture(ctx); |
||
799 | _mesa_update_default_objects_buffer_objects(ctx); |
||
800 | |||
801 | return GL_TRUE; |
||
802 | } |
||
803 | |||
804 | |||
805 | /** |
||
806 | * This is the default function we plug into all dispatch table slots |
||
807 | * This helps prevents a segfault when someone calls a GL function without |
||
808 | * first checking if the extension's supported. |
||
809 | */ |
||
810 | static int |
||
811 | generic_nop(void) |
||
812 | { |
||
813 | _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)"); |
||
814 | return 0; |
||
815 | } |
||
816 | |||
817 | |||
818 | /** |
||
819 | * Allocate and initialize a new dispatch table. |
||
820 | */ |
||
821 | struct _glapi_table * |
||
822 | _mesa_alloc_dispatch_table(int size) |
||
823 | { |
||
824 | /* Find the larger of Mesa's dispatch table and libGL's dispatch table. |
||
825 | * In practice, this'll be the same for stand-alone Mesa. But for DRI |
||
826 | * Mesa we do this to accomodate different versions of libGL and various |
||
827 | * DRI drivers. |
||
828 | */ |
||
829 | GLint numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT); |
||
830 | struct _glapi_table *table; |
||
831 | |||
832 | /* should never happen, but just in case */ |
||
833 | numEntries = MAX2(numEntries, size); |
||
834 | |||
835 | table = (struct _glapi_table *) malloc(numEntries * sizeof(_glapi_proc)); |
||
836 | if (table) { |
||
837 | _glapi_proc *entry = (_glapi_proc *) table; |
||
838 | GLint i; |
||
839 | for (i = 0; i < numEntries; i++) { |
||
840 | entry[i] = (_glapi_proc) generic_nop; |
||
841 | } |
||
842 | } |
||
843 | return table; |
||
844 | } |
||
845 | |||
846 | |||
847 | /** |
||
848 | * Initialize a struct gl_context struct (rendering context). |
||
849 | * |
||
850 | * This includes allocating all the other structs and arrays which hang off of |
||
851 | * the context by pointers. |
||
852 | * Note that the driver needs to pass in its dd_function_table here since |
||
853 | * we need to at least call driverFunctions->NewTextureObject to create the |
||
854 | * default texture objects. |
||
855 | * |
||
856 | * Called by _mesa_create_context(). |
||
857 | * |
||
858 | * Performs the imports and exports callback tables initialization, and |
||
859 | * miscellaneous one-time initializations. If no shared context is supplied one |
||
860 | * is allocated, and increase its reference count. Setups the GL API dispatch |
||
861 | * tables. Initialize the TNL module. Sets the maximum Z buffer depth. |
||
862 | * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables |
||
863 | * for debug flags. |
||
864 | * |
||
865 | * \param ctx the context to initialize |
||
866 | * \param api the GL API type to create the context for |
||
867 | * \param visual describes the visual attributes for this context |
||
868 | * \param share_list points to context to share textures, display lists, |
||
869 | * etc with, or NULL |
||
870 | * \param driverFunctions table of device driver functions for this context |
||
871 | * to use |
||
872 | * \param driverContext pointer to driver-specific context data |
||
873 | */ |
||
874 | GLboolean |
||
875 | _mesa_initialize_context_for_api(struct gl_context *ctx, |
||
876 | gl_api api, |
||
877 | const struct gl_config *visual, |
||
878 | struct gl_context *share_list, |
||
879 | const struct dd_function_table *driverFunctions, |
||
880 | void *driverContext) |
||
881 | { |
||
882 | struct gl_shared_state *shared; |
||
883 | int i; |
||
884 | |||
885 | /*ASSERT(driverContext);*/ |
||
886 | assert(driverFunctions->NewTextureObject); |
||
887 | assert(driverFunctions->FreeTexImageData); |
||
888 | |||
889 | ctx->API = api; |
||
890 | ctx->Visual = *visual; |
||
891 | ctx->DrawBuffer = NULL; |
||
892 | ctx->ReadBuffer = NULL; |
||
893 | ctx->WinSysDrawBuffer = NULL; |
||
894 | ctx->WinSysReadBuffer = NULL; |
||
895 | |||
896 | /* misc one-time initializations */ |
||
897 | one_time_init(ctx); |
||
898 | |||
899 | /* Plug in driver functions and context pointer here. |
||
900 | * This is important because when we call alloc_shared_state() below |
||
901 | * we'll call ctx->Driver.NewTextureObject() to create the default |
||
902 | * textures. |
||
903 | */ |
||
904 | ctx->Driver = *driverFunctions; |
||
905 | ctx->DriverCtx = driverContext; |
||
906 | |||
907 | if (share_list) { |
||
908 | /* share state with another context */ |
||
909 | shared = share_list->Shared; |
||
910 | } |
||
911 | else { |
||
912 | /* allocate new, unshared state */ |
||
913 | shared = _mesa_alloc_shared_state(ctx); |
||
914 | if (!shared) |
||
915 | return GL_FALSE; |
||
916 | } |
||
917 | |||
918 | _glthread_LOCK_MUTEX(shared->Mutex); |
||
919 | ctx->Shared = shared; |
||
920 | shared->RefCount++; |
||
921 | _glthread_UNLOCK_MUTEX(shared->Mutex); |
||
922 | |||
923 | if (!init_attrib_groups( ctx )) { |
||
924 | _mesa_release_shared_state(ctx, ctx->Shared); |
||
925 | return GL_FALSE; |
||
926 | } |
||
927 | |||
928 | #if FEATURE_dispatch |
||
929 | /* setup the API dispatch tables */ |
||
930 | switch (ctx->API) { |
||
931 | #if FEATURE_GL |
||
932 | case API_OPENGL: |
||
933 | ctx->Exec = _mesa_create_exec_table(); |
||
934 | break; |
||
935 | #endif |
||
936 | #if FEATURE_ES1 |
||
937 | case API_OPENGLES: |
||
938 | ctx->Exec = _mesa_create_exec_table_es1(); |
||
939 | break; |
||
940 | #endif |
||
941 | #if FEATURE_ES2 |
||
942 | case API_OPENGLES2: |
||
943 | ctx->Exec = _mesa_create_exec_table_es2(); |
||
944 | break; |
||
945 | #endif |
||
946 | default: |
||
947 | _mesa_problem(ctx, "unknown or unsupported API"); |
||
948 | break; |
||
949 | } |
||
950 | |||
951 | if (!ctx->Exec) { |
||
952 | _mesa_release_shared_state(ctx, ctx->Shared); |
||
953 | return GL_FALSE; |
||
954 | } |
||
955 | #endif |
||
956 | ctx->CurrentDispatch = ctx->Exec; |
||
957 | |||
958 | ctx->FragmentProgram._MaintainTexEnvProgram |
||
959 | = (_mesa_getenv("MESA_TEX_PROG") != NULL); |
||
960 | |||
961 | ctx->VertexProgram._MaintainTnlProgram |
||
962 | = (_mesa_getenv("MESA_TNL_PROG") != NULL); |
||
963 | if (ctx->VertexProgram._MaintainTnlProgram) { |
||
964 | /* this is required... */ |
||
965 | ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE; |
||
966 | } |
||
967 | |||
968 | switch (ctx->API) { |
||
969 | case API_OPENGL: |
||
970 | #if FEATURE_dlist |
||
971 | ctx->Save = _mesa_create_save_table(); |
||
972 | if (!ctx->Save) { |
||
973 | _mesa_release_shared_state(ctx, ctx->Shared); |
||
974 | free(ctx->Exec); |
||
975 | return GL_FALSE; |
||
976 | } |
||
977 | |||
978 | _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt ); |
||
979 | #endif |
||
980 | break; |
||
981 | case API_OPENGLES: |
||
982 | /** |
||
983 | * GL_OES_texture_cube_map says |
||
984 | * "Initially all texture generation modes are set to REFLECTION_MAP_OES" |
||
985 | */ |
||
986 | for (i = 0; i < MAX_TEXTURE_UNITS; i++) { |
||
987 | struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i]; |
||
988 | texUnit->GenS.Mode = GL_REFLECTION_MAP_NV; |
||
989 | texUnit->GenT.Mode = GL_REFLECTION_MAP_NV; |
||
990 | texUnit->GenR.Mode = GL_REFLECTION_MAP_NV; |
||
991 | texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV; |
||
992 | texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV; |
||
993 | texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV; |
||
994 | } |
||
995 | break; |
||
996 | case API_OPENGLES2: |
||
997 | ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE; |
||
998 | ctx->VertexProgram._MaintainTnlProgram = GL_TRUE; |
||
999 | ctx->Point.PointSprite = GL_TRUE; /* always on for ES 2.x */ |
||
1000 | break; |
||
1001 | } |
||
1002 | |||
1003 | ctx->FirstTimeCurrent = GL_TRUE; |
||
1004 | |||
1005 | return GL_TRUE; |
||
1006 | } |
||
1007 | |||
1008 | |||
1009 | /** |
||
1010 | * Initialize an OpenGL context. |
||
1011 | */ |
||
1012 | GLboolean |
||
1013 | _mesa_initialize_context(struct gl_context *ctx, |
||
1014 | const struct gl_config *visual, |
||
1015 | struct gl_context *share_list, |
||
1016 | const struct dd_function_table *driverFunctions, |
||
1017 | void *driverContext) |
||
1018 | { |
||
1019 | return _mesa_initialize_context_for_api(ctx, |
||
1020 | API_OPENGL, |
||
1021 | visual, |
||
1022 | share_list, |
||
1023 | driverFunctions, |
||
1024 | driverContext); |
||
1025 | } |
||
1026 | |||
1027 | |||
1028 | /** |
||
1029 | * Allocate and initialize a struct gl_context structure. |
||
1030 | * Note that the driver needs to pass in its dd_function_table here since |
||
1031 | * we need to at least call driverFunctions->NewTextureObject to initialize |
||
1032 | * the rendering context. |
||
1033 | * |
||
1034 | * \param api the GL API type to create the context for |
||
1035 | * \param visual a struct gl_config pointer (we copy the struct contents) |
||
1036 | * \param share_list another context to share display lists with or NULL |
||
1037 | * \param driverFunctions points to the dd_function_table into which the |
||
1038 | * driver has plugged in all its special functions. |
||
1039 | * \param driverContext points to the device driver's private context state |
||
1040 | * |
||
1041 | * \return pointer to a new __struct gl_contextRec or NULL if error. |
||
1042 | */ |
||
1043 | struct gl_context * |
||
1044 | _mesa_create_context_for_api(gl_api api, |
||
1045 | const struct gl_config *visual, |
||
1046 | struct gl_context *share_list, |
||
1047 | const struct dd_function_table *driverFunctions, |
||
1048 | void *driverContext) |
||
1049 | { |
||
1050 | struct gl_context *ctx; |
||
1051 | |||
1052 | ASSERT(visual); |
||
1053 | /*ASSERT(driverContext);*/ |
||
1054 | |||
1055 | ctx = (struct gl_context *) calloc(1, sizeof(struct gl_context)); |
||
1056 | if (!ctx) |
||
1057 | return NULL; |
||
1058 | |||
1059 | if (_mesa_initialize_context_for_api(ctx, api, visual, share_list, |
||
1060 | driverFunctions, driverContext)) { |
||
1061 | return ctx; |
||
1062 | } |
||
1063 | else { |
||
1064 | free(ctx); |
||
1065 | return NULL; |
||
1066 | } |
||
1067 | } |
||
1068 | |||
1069 | |||
1070 | /** |
||
1071 | * Create an OpenGL context. |
||
1072 | */ |
||
1073 | struct gl_context * |
||
1074 | _mesa_create_context(const struct gl_config *visual, |
||
1075 | struct gl_context *share_list, |
||
1076 | const struct dd_function_table *driverFunctions, |
||
1077 | void *driverContext) |
||
1078 | { |
||
1079 | return _mesa_create_context_for_api(API_OPENGL, visual, |
||
1080 | share_list, |
||
1081 | driverFunctions, |
||
1082 | driverContext); |
||
1083 | } |
||
1084 | |||
1085 | |||
1086 | /** |
||
1087 | * Free the data associated with the given context. |
||
1088 | * |
||
1089 | * But doesn't free the struct gl_context struct itself. |
||
1090 | * |
||
1091 | * \sa _mesa_initialize_context() and init_attrib_groups(). |
||
1092 | */ |
||
1093 | void |
||
1094 | _mesa_free_context_data( struct gl_context *ctx ) |
||
1095 | { |
||
1096 | if (!_mesa_get_current_context()){ |
||
1097 | /* No current context, but we may need one in order to delete |
||
1098 | * texture objs, etc. So temporarily bind the context now. |
||
1099 | */ |
||
1100 | _mesa_make_current(ctx, NULL, NULL); |
||
1101 | } |
||
1102 | |||
1103 | /* unreference WinSysDraw/Read buffers */ |
||
1104 | _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL); |
||
1105 | _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL); |
||
1106 | _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL); |
||
1107 | _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL); |
||
1108 | |||
1109 | _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL); |
||
1110 | _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL); |
||
1111 | _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL); |
||
1112 | |||
1113 | _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL); |
||
1114 | _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL); |
||
1115 | _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL); |
||
1116 | |||
1117 | _mesa_free_attrib_data(ctx); |
||
1118 | _mesa_free_buffer_objects(ctx); |
||
1119 | _mesa_free_lighting_data( ctx ); |
||
1120 | _mesa_free_eval_data( ctx ); |
||
1121 | _mesa_free_texture_data( ctx ); |
||
1122 | _mesa_free_matrix_data( ctx ); |
||
1123 | _mesa_free_viewport_data( ctx ); |
||
1124 | _mesa_free_program_data(ctx); |
||
1125 | _mesa_free_shader_state(ctx); |
||
1126 | _mesa_free_queryobj_data(ctx); |
||
1127 | _mesa_free_sync_data(ctx); |
||
1128 | _mesa_free_varray_data(ctx); |
||
1129 | _mesa_free_transform_feedback(ctx); |
||
1130 | |||
1131 | _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj); |
||
1132 | |||
1133 | #if FEATURE_ARB_pixel_buffer_object |
||
1134 | _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL); |
||
1135 | _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL); |
||
1136 | _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL); |
||
1137 | #endif |
||
1138 | |||
1139 | #if FEATURE_ARB_vertex_buffer_object |
||
1140 | _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL); |
||
1141 | _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL); |
||
1142 | #endif |
||
1143 | |||
1144 | /* free dispatch tables */ |
||
1145 | free(ctx->Exec); |
||
1146 | free(ctx->Save); |
||
1147 | |||
1148 | /* Shared context state (display lists, textures, etc) */ |
||
1149 | _mesa_release_shared_state( ctx, ctx->Shared ); |
||
1150 | |||
1151 | /* needs to be after freeing shared state */ |
||
1152 | _mesa_free_display_list_data(ctx); |
||
1153 | |||
1154 | if (ctx->Extensions.String) |
||
1155 | free((void *) ctx->Extensions.String); |
||
1156 | |||
1157 | if (ctx->VersionString) |
||
1158 | free(ctx->VersionString); |
||
1159 | |||
1160 | /* unbind the context if it's currently bound */ |
||
1161 | if (ctx == _mesa_get_current_context()) { |
||
1162 | _mesa_make_current(NULL, NULL, NULL); |
||
1163 | } |
||
1164 | } |
||
1165 | |||
1166 | |||
1167 | /** |
||
1168 | * Destroy a struct gl_context structure. |
||
1169 | * |
||
1170 | * \param ctx GL context. |
||
1171 | * |
||
1172 | * Calls _mesa_free_context_data() and frees the gl_context object itself. |
||
1173 | */ |
||
1174 | void |
||
1175 | _mesa_destroy_context( struct gl_context *ctx ) |
||
1176 | { |
||
1177 | if (ctx) { |
||
1178 | _mesa_free_context_data(ctx); |
||
1179 | free( (void *) ctx ); |
||
1180 | } |
||
1181 | } |
||
1182 | |||
1183 | |||
1184 | #if _HAVE_FULL_GL |
||
1185 | /** |
||
1186 | * Copy attribute groups from one context to another. |
||
1187 | * |
||
1188 | * \param src source context |
||
1189 | * \param dst destination context |
||
1190 | * \param mask bitwise OR of GL_*_BIT flags |
||
1191 | * |
||
1192 | * According to the bits specified in \p mask, copies the corresponding |
||
1193 | * attributes from \p src into \p dst. For many of the attributes a simple \c |
||
1194 | * memcpy is not enough due to the existence of internal pointers in their data |
||
1195 | * structures. |
||
1196 | */ |
||
1197 | void |
||
1198 | _mesa_copy_context( const struct gl_context *src, struct gl_context *dst, GLuint mask ) |
||
1199 | { |
||
1200 | if (mask & GL_ACCUM_BUFFER_BIT) { |
||
1201 | /* OK to memcpy */ |
||
1202 | dst->Accum = src->Accum; |
||
1203 | } |
||
1204 | if (mask & GL_COLOR_BUFFER_BIT) { |
||
1205 | /* OK to memcpy */ |
||
1206 | dst->Color = src->Color; |
||
1207 | } |
||
1208 | if (mask & GL_CURRENT_BIT) { |
||
1209 | /* OK to memcpy */ |
||
1210 | dst->Current = src->Current; |
||
1211 | } |
||
1212 | if (mask & GL_DEPTH_BUFFER_BIT) { |
||
1213 | /* OK to memcpy */ |
||
1214 | dst->Depth = src->Depth; |
||
1215 | } |
||
1216 | if (mask & GL_ENABLE_BIT) { |
||
1217 | /* no op */ |
||
1218 | } |
||
1219 | if (mask & GL_EVAL_BIT) { |
||
1220 | /* OK to memcpy */ |
||
1221 | dst->Eval = src->Eval; |
||
1222 | } |
||
1223 | if (mask & GL_FOG_BIT) { |
||
1224 | /* OK to memcpy */ |
||
1225 | dst->Fog = src->Fog; |
||
1226 | } |
||
1227 | if (mask & GL_HINT_BIT) { |
||
1228 | /* OK to memcpy */ |
||
1229 | dst->Hint = src->Hint; |
||
1230 | } |
||
1231 | if (mask & GL_LIGHTING_BIT) { |
||
1232 | GLuint i; |
||
1233 | /* begin with memcpy */ |
||
1234 | dst->Light = src->Light; |
||
1235 | /* fixup linked lists to prevent pointer insanity */ |
||
1236 | make_empty_list( &(dst->Light.EnabledList) ); |
||
1237 | for (i = 0; i < MAX_LIGHTS; i++) { |
||
1238 | if (dst->Light.Light[i].Enabled) { |
||
1239 | insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i])); |
||
1240 | } |
||
1241 | } |
||
1242 | } |
||
1243 | if (mask & GL_LINE_BIT) { |
||
1244 | /* OK to memcpy */ |
||
1245 | dst->Line = src->Line; |
||
1246 | } |
||
1247 | if (mask & GL_LIST_BIT) { |
||
1248 | /* OK to memcpy */ |
||
1249 | dst->List = src->List; |
||
1250 | } |
||
1251 | if (mask & GL_PIXEL_MODE_BIT) { |
||
1252 | /* OK to memcpy */ |
||
1253 | dst->Pixel = src->Pixel; |
||
1254 | } |
||
1255 | if (mask & GL_POINT_BIT) { |
||
1256 | /* OK to memcpy */ |
||
1257 | dst->Point = src->Point; |
||
1258 | } |
||
1259 | if (mask & GL_POLYGON_BIT) { |
||
1260 | /* OK to memcpy */ |
||
1261 | dst->Polygon = src->Polygon; |
||
1262 | } |
||
1263 | if (mask & GL_POLYGON_STIPPLE_BIT) { |
||
1264 | /* Use loop instead of memcpy due to problem with Portland Group's |
||
1265 | * C compiler. Reported by John Stone. |
||
1266 | */ |
||
1267 | GLuint i; |
||
1268 | for (i = 0; i < 32; i++) { |
||
1269 | dst->PolygonStipple[i] = src->PolygonStipple[i]; |
||
1270 | } |
||
1271 | } |
||
1272 | if (mask & GL_SCISSOR_BIT) { |
||
1273 | /* OK to memcpy */ |
||
1274 | dst->Scissor = src->Scissor; |
||
1275 | } |
||
1276 | if (mask & GL_STENCIL_BUFFER_BIT) { |
||
1277 | /* OK to memcpy */ |
||
1278 | dst->Stencil = src->Stencil; |
||
1279 | } |
||
1280 | if (mask & GL_TEXTURE_BIT) { |
||
1281 | /* Cannot memcpy because of pointers */ |
||
1282 | _mesa_copy_texture_state(src, dst); |
||
1283 | } |
||
1284 | if (mask & GL_TRANSFORM_BIT) { |
||
1285 | /* OK to memcpy */ |
||
1286 | dst->Transform = src->Transform; |
||
1287 | } |
||
1288 | if (mask & GL_VIEWPORT_BIT) { |
||
1289 | /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */ |
||
1290 | dst->Viewport.X = src->Viewport.X; |
||
1291 | dst->Viewport.Y = src->Viewport.Y; |
||
1292 | dst->Viewport.Width = src->Viewport.Width; |
||
1293 | dst->Viewport.Height = src->Viewport.Height; |
||
1294 | dst->Viewport.Near = src->Viewport.Near; |
||
1295 | dst->Viewport.Far = src->Viewport.Far; |
||
1296 | _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap); |
||
1297 | } |
||
1298 | |||
1299 | /* XXX FIXME: Call callbacks? |
||
1300 | */ |
||
1301 | dst->NewState = _NEW_ALL; |
||
1302 | } |
||
1303 | #endif |
||
1304 | |||
1305 | |||
1306 | /** |
||
1307 | * Check if the given context can render into the given framebuffer |
||
1308 | * by checking visual attributes. |
||
1309 | * |
||
1310 | * Most of these tests could go away because Mesa is now pretty flexible |
||
1311 | * in terms of mixing rendering contexts with framebuffers. As long |
||
1312 | * as RGB vs. CI mode agree, we're probably good. |
||
1313 | * |
||
1314 | * \return GL_TRUE if compatible, GL_FALSE otherwise. |
||
1315 | */ |
||
1316 | static GLboolean |
||
1317 | check_compatible(const struct gl_context *ctx, |
||
1318 | const struct gl_framebuffer *buffer) |
||
1319 | { |
||
1320 | const struct gl_config *ctxvis = &ctx->Visual; |
||
1321 | const struct gl_config *bufvis = &buffer->Visual; |
||
1322 | |||
1323 | if (buffer == _mesa_get_incomplete_framebuffer()) |
||
1324 | return GL_TRUE; |
||
1325 | |||
1326 | #if 0 |
||
1327 | /* disabling this fixes the fgl_glxgears pbuffer demo */ |
||
1328 | if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode) |
||
1329 | return GL_FALSE; |
||
1330 | #endif |
||
1331 | if (ctxvis->stereoMode && !bufvis->stereoMode) |
||
1332 | return GL_FALSE; |
||
1333 | if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer) |
||
1334 | return GL_FALSE; |
||
1335 | if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer) |
||
1336 | return GL_FALSE; |
||
1337 | if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer) |
||
1338 | return GL_FALSE; |
||
1339 | if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask) |
||
1340 | return GL_FALSE; |
||
1341 | if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask) |
||
1342 | return GL_FALSE; |
||
1343 | if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask) |
||
1344 | return GL_FALSE; |
||
1345 | #if 0 |
||
1346 | /* disabled (see bug 11161) */ |
||
1347 | if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits) |
||
1348 | return GL_FALSE; |
||
1349 | #endif |
||
1350 | if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits) |
||
1351 | return GL_FALSE; |
||
1352 | |||
1353 | return GL_TRUE; |
||
1354 | } |
||
1355 | |||
1356 | |||
1357 | /** |
||
1358 | * Do one-time initialization for the given framebuffer. Specifically, |
||
1359 | * ask the driver for the window's current size and update the framebuffer |
||
1360 | * object to match. |
||
1361 | * Really, the device driver should totally take care of this. |
||
1362 | */ |
||
1363 | static void |
||
1364 | initialize_framebuffer_size(struct gl_context *ctx, struct gl_framebuffer *fb) |
||
1365 | { |
||
1366 | GLuint width, height; |
||
1367 | if (ctx->Driver.GetBufferSize) { |
||
1368 | ctx->Driver.GetBufferSize(fb, &width, &height); |
||
1369 | if (ctx->Driver.ResizeBuffers) |
||
1370 | ctx->Driver.ResizeBuffers(ctx, fb, width, height); |
||
1371 | fb->Initialized = GL_TRUE; |
||
1372 | } |
||
1373 | } |
||
1374 | |||
1375 | |||
1376 | /** |
||
1377 | * Check if the viewport/scissor size has not yet been initialized. |
||
1378 | * Initialize the size if the given width and height are non-zero. |
||
1379 | */ |
||
1380 | void |
||
1381 | _mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height) |
||
1382 | { |
||
1383 | if (!ctx->ViewportInitialized && width > 0 && height > 0) { |
||
1384 | /* Note: set flag here, before calling _mesa_set_viewport(), to prevent |
||
1385 | * potential infinite recursion. |
||
1386 | */ |
||
1387 | ctx->ViewportInitialized = GL_TRUE; |
||
1388 | _mesa_set_viewport(ctx, 0, 0, width, height); |
||
1389 | _mesa_set_scissor(ctx, 0, 0, width, height); |
||
1390 | } |
||
1391 | } |
||
1392 | |||
1393 | |||
1394 | /** |
||
1395 | * Bind the given context to the given drawBuffer and readBuffer and |
||
1396 | * make it the current context for the calling thread. |
||
1397 | * We'll render into the drawBuffer and read pixels from the |
||
1398 | * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc). |
||
1399 | * |
||
1400 | * We check that the context's and framebuffer's visuals are compatible |
||
1401 | * and return immediately if they're not. |
||
1402 | * |
||
1403 | * \param newCtx the new GL context. If NULL then there will be no current GL |
||
1404 | * context. |
||
1405 | * \param drawBuffer the drawing framebuffer |
||
1406 | * \param readBuffer the reading framebuffer |
||
1407 | */ |
||
1408 | GLboolean |
||
1409 | _mesa_make_current( struct gl_context *newCtx, |
||
1410 | struct gl_framebuffer *drawBuffer, |
||
1411 | struct gl_framebuffer *readBuffer ) |
||
1412 | { |
||
1413 | GET_CURRENT_CONTEXT(curCtx); |
||
1414 | |||
1415 | if (MESA_VERBOSE & VERBOSE_API) |
||
1416 | _mesa_debug(newCtx, "_mesa_make_current()\n"); |
||
1417 | |||
1418 | /* Check that the context's and framebuffer's visuals are compatible. |
||
1419 | */ |
||
1420 | if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) { |
||
1421 | if (!check_compatible(newCtx, drawBuffer)) { |
||
1422 | _mesa_warning(newCtx, |
||
1423 | "MakeCurrent: incompatible visuals for context and drawbuffer"); |
||
1424 | return GL_FALSE; |
||
1425 | } |
||
1426 | } |
||
1427 | if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) { |
||
1428 | if (!check_compatible(newCtx, readBuffer)) { |
||
1429 | _mesa_warning(newCtx, |
||
1430 | "MakeCurrent: incompatible visuals for context and readbuffer"); |
||
1431 | return GL_FALSE; |
||
1432 | } |
||
1433 | } |
||
1434 | |||
1435 | if (curCtx && |
||
1436 | (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) && /* make sure this context is valid for flushing */ |
||
1437 | curCtx != newCtx) |
||
1438 | _mesa_flush(curCtx); |
||
1439 | |||
1440 | /* We used to call _glapi_check_multithread() here. Now do it in drivers */ |
||
1441 | _glapi_set_context((void *) newCtx); |
||
1442 | ASSERT(_mesa_get_current_context() == newCtx); |
||
1443 | |||
1444 | if (!newCtx) { |
||
1445 | _glapi_set_dispatch(NULL); /* none current */ |
||
1446 | } |
||
1447 | else { |
||
1448 | _glapi_set_dispatch(newCtx->CurrentDispatch); |
||
1449 | |||
1450 | if (drawBuffer && readBuffer) { |
||
1451 | /* TODO: check if newCtx and buffer's visual match??? */ |
||
1452 | |||
1453 | ASSERT(drawBuffer->Name == 0); |
||
1454 | ASSERT(readBuffer->Name == 0); |
||
1455 | _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer); |
||
1456 | _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer); |
||
1457 | |||
1458 | /* |
||
1459 | * Only set the context's Draw/ReadBuffer fields if they're NULL |
||
1460 | * or not bound to a user-created FBO. |
||
1461 | */ |
||
1462 | if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) { |
||
1463 | /* KW: merge conflict here, revisit. |
||
1464 | */ |
||
1465 | /* fix up the fb fields - these will end up wrong otherwise |
||
1466 | * if the DRIdrawable changes, and everything relies on them. |
||
1467 | * This is a bit messy (same as needed in _mesa_BindFramebufferEXT) |
||
1468 | */ |
||
1469 | unsigned int i; |
||
1470 | GLenum buffers[MAX_DRAW_BUFFERS]; |
||
1471 | |||
1472 | _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer); |
||
1473 | |||
1474 | for(i = 0; i < newCtx->Const.MaxDrawBuffers; i++) { |
||
1475 | buffers[i] = newCtx->Color.DrawBuffer[i]; |
||
1476 | } |
||
1477 | |||
1478 | _mesa_drawbuffers(newCtx, newCtx->Const.MaxDrawBuffers, |
||
1479 | buffers, NULL); |
||
1480 | } |
||
1481 | if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) { |
||
1482 | _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer); |
||
1483 | } |
||
1484 | |||
1485 | /* XXX only set this flag if we're really changing the draw/read |
||
1486 | * framebuffer bindings. |
||
1487 | */ |
||
1488 | newCtx->NewState |= _NEW_BUFFERS; |
||
1489 | |||
1490 | #if 1 |
||
1491 | /* We want to get rid of these lines: */ |
||
1492 | |||
1493 | #if _HAVE_FULL_GL |
||
1494 | if (!drawBuffer->Initialized) { |
||
1495 | initialize_framebuffer_size(newCtx, drawBuffer); |
||
1496 | } |
||
1497 | if (readBuffer != drawBuffer && !readBuffer->Initialized) { |
||
1498 | initialize_framebuffer_size(newCtx, readBuffer); |
||
1499 | } |
||
1500 | |||
1501 | _mesa_resizebuffers(newCtx); |
||
1502 | #endif |
||
1503 | |||
1504 | #else |
||
1505 | /* We want the drawBuffer and readBuffer to be initialized by |
||
1506 | * the driver. |
||
1507 | * This generally means the Width and Height match the actual |
||
1508 | * window size and the renderbuffers (both hardware and software |
||
1509 | * based) are allocated to match. The later can generally be |
||
1510 | * done with a call to _mesa_resize_framebuffer(). |
||
1511 | * |
||
1512 | * It's theoretically possible for a buffer to have zero width |
||
1513 | * or height, but for now, assert check that the driver did what's |
||
1514 | * expected of it. |
||
1515 | */ |
||
1516 | ASSERT(drawBuffer->Width > 0); |
||
1517 | ASSERT(drawBuffer->Height > 0); |
||
1518 | #endif |
||
1519 | |||
1520 | if (drawBuffer) { |
||
1521 | _mesa_check_init_viewport(newCtx, |
||
1522 | drawBuffer->Width, drawBuffer->Height); |
||
1523 | } |
||
1524 | } |
||
1525 | |||
1526 | if (newCtx->FirstTimeCurrent) { |
||
1527 | _mesa_compute_version(newCtx); |
||
1528 | |||
1529 | newCtx->Extensions.String = _mesa_make_extension_string(newCtx); |
||
1530 | |||
1531 | check_context_limits(newCtx); |
||
1532 | |||
1533 | /* We can use this to help debug user's problems. Tell them to set |
||
1534 | * the MESA_INFO env variable before running their app. Then the |
||
1535 | * first time each context is made current we'll print some useful |
||
1536 | * information. |
||
1537 | */ |
||
1538 | if (_mesa_getenv("MESA_INFO")) { |
||
1539 | _mesa_print_info(); |
||
1540 | } |
||
1541 | |||
1542 | newCtx->FirstTimeCurrent = GL_FALSE; |
||
1543 | } |
||
1544 | } |
||
1545 | |||
1546 | return GL_TRUE; |
||
1547 | } |
||
1548 | |||
1549 | |||
1550 | /** |
||
1551 | * Make context 'ctx' share the display lists, textures and programs |
||
1552 | * that are associated with 'ctxToShare'. |
||
1553 | * Any display lists, textures or programs associated with 'ctx' will |
||
1554 | * be deleted if nobody else is sharing them. |
||
1555 | */ |
||
1556 | GLboolean |
||
1557 | _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare) |
||
1558 | { |
||
1559 | if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) { |
||
1560 | struct gl_shared_state *oldSharedState = ctx->Shared; |
||
1561 | |||
1562 | ctx->Shared = ctxToShare->Shared; |
||
1563 | |||
1564 | _glthread_LOCK_MUTEX(ctx->Shared->Mutex); |
||
1565 | ctx->Shared->RefCount++; |
||
1566 | _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); |
||
1567 | |||
1568 | update_default_objects(ctx); |
||
1569 | |||
1570 | _mesa_release_shared_state(ctx, oldSharedState); |
||
1571 | |||
1572 | return GL_TRUE; |
||
1573 | } |
||
1574 | else { |
||
1575 | return GL_FALSE; |
||
1576 | } |
||
1577 | } |
||
1578 | |||
1579 | |||
1580 | |||
1581 | /** |
||
1582 | * \return pointer to the current GL context for this thread. |
||
1583 | * |
||
1584 | * Calls _glapi_get_context(). This isn't the fastest way to get the current |
||
1585 | * context. If you need speed, see the #GET_CURRENT_CONTEXT macro in |
||
1586 | * context.h. |
||
1587 | */ |
||
1588 | struct gl_context * |
||
1589 | _mesa_get_current_context( void ) |
||
1590 | { |
||
1591 | return (struct gl_context *) _glapi_get_context(); |
||
1592 | } |
||
1593 | |||
1594 | |||
1595 | /** |
||
1596 | * Get context's current API dispatch table. |
||
1597 | * |
||
1598 | * It'll either be the immediate-mode execute dispatcher or the display list |
||
1599 | * compile dispatcher. |
||
1600 | * |
||
1601 | * \param ctx GL context. |
||
1602 | * |
||
1603 | * \return pointer to dispatch_table. |
||
1604 | * |
||
1605 | * Simply returns __struct gl_contextRec::CurrentDispatch. |
||
1606 | */ |
||
1607 | struct _glapi_table * |
||
1608 | _mesa_get_dispatch(struct gl_context *ctx) |
||
1609 | { |
||
1610 | return ctx->CurrentDispatch; |
||
1611 | } |
||
1612 | |||
1613 | /*@}*/ |
||
1614 | |||
1615 | |||
1616 | /**********************************************************************/ |
||
1617 | /** \name Miscellaneous functions */ |
||
1618 | /**********************************************************************/ |
||
1619 | /*@{*/ |
||
1620 | |||
1621 | /** |
||
1622 | * Record an error. |
||
1623 | * |
||
1624 | * \param ctx GL context. |
||
1625 | * \param error error code. |
||
1626 | * |
||
1627 | * Records the given error code and call the driver's dd_function_table::Error |
||
1628 | * function if defined. |
||
1629 | * |
||
1630 | * \sa |
||
1631 | * This is called via _mesa_error(). |
||
1632 | */ |
||
1633 | void |
||
1634 | _mesa_record_error(struct gl_context *ctx, GLenum error) |
||
1635 | { |
||
1636 | if (!ctx) |
||
1637 | return; |
||
1638 | |||
1639 | if (ctx->ErrorValue == GL_NO_ERROR) { |
||
1640 | ctx->ErrorValue = error; |
||
1641 | } |
||
1642 | |||
1643 | /* Call device driver's error handler, if any. This is used on the Mac. */ |
||
1644 | if (ctx->Driver.Error) { |
||
1645 | ctx->Driver.Error(ctx); |
||
1646 | } |
||
1647 | } |
||
1648 | |||
1649 | |||
1650 | /** |
||
1651 | * Flush commands and wait for completion. |
||
1652 | */ |
||
1653 | void |
||
1654 | _mesa_finish(struct gl_context *ctx) |
||
1655 | { |
||
1656 | FLUSH_CURRENT( ctx, 0 ); |
||
1657 | if (ctx->Driver.Finish) { |
||
1658 | ctx->Driver.Finish(ctx); |
||
1659 | } |
||
1660 | } |
||
1661 | |||
1662 | |||
1663 | /** |
||
1664 | * Flush commands. |
||
1665 | */ |
||
1666 | void |
||
1667 | _mesa_flush(struct gl_context *ctx) |
||
1668 | { |
||
1669 | FLUSH_CURRENT( ctx, 0 ); |
||
1670 | if (ctx->Driver.Flush) { |
||
1671 | ctx->Driver.Flush(ctx); |
||
1672 | } |
||
1673 | } |
||
1674 | |||
1675 | |||
1676 | |||
1677 | /** |
||
1678 | * Execute glFinish(). |
||
1679 | * |
||
1680 | * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the |
||
1681 | * dd_function_table::Finish driver callback, if not NULL. |
||
1682 | */ |
||
1683 | void GLAPIENTRY |
||
1684 | _mesa_Finish(void) |
||
1685 | { |
||
1686 | GET_CURRENT_CONTEXT(ctx); |
||
1687 | ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); |
||
1688 | _mesa_finish(ctx); |
||
1689 | } |
||
1690 | |||
1691 | |||
1692 | /** |
||
1693 | * Execute glFlush(). |
||
1694 | * |
||
1695 | * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the |
||
1696 | * dd_function_table::Flush driver callback, if not NULL. |
||
1697 | */ |
||
1698 | void GLAPIENTRY |
||
1699 | _mesa_Flush(void) |
||
1700 | { |
||
1701 | GET_CURRENT_CONTEXT(ctx); |
||
1702 | ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); |
||
1703 | _mesa_flush(ctx); |
||
1704 | } |
||
1705 | |||
1706 | |||
1707 | /** |
||
1708 | * Set mvp_with_dp4 flag. If a driver has a preference for DP4 over |
||
1709 | * MUL/MAD, or vice versa, call this function to register that. |
||
1710 | * Otherwise we default to MUL/MAD. |
||
1711 | */ |
||
1712 | void |
||
1713 | _mesa_set_mvp_with_dp4( struct gl_context *ctx, |
||
1714 | GLboolean flag ) |
||
1715 | { |
||
1716 | ctx->mvp_with_dp4 = flag; |
||
1717 | } |
||
1718 | |||
1719 | |||
1720 | |||
1721 | /** |
||
1722 | * Prior to drawing anything with glBegin, glDrawArrays, etc. this function |
||
1723 | * is called to see if it's valid to render. This involves checking that |
||
1724 | * the current shader is valid and the framebuffer is complete. |
||
1725 | * If an error is detected it'll be recorded here. |
||
1726 | * \return GL_TRUE if OK to render, GL_FALSE if not |
||
1727 | */ |
||
1728 | GLboolean |
||
1729 | _mesa_valid_to_render(struct gl_context *ctx, const char *where) |
||
1730 | { |
||
1731 | bool vert_from_glsl_shader = false; |
||
1732 | bool geom_from_glsl_shader = false; |
||
1733 | bool frag_from_glsl_shader = false; |
||
1734 | |||
1735 | /* This depends on having up to date derived state (shaders) */ |
||
1736 | if (ctx->NewState) |
||
1737 | _mesa_update_state(ctx); |
||
1738 | |||
1739 | if (ctx->Shader.CurrentVertexProgram) { |
||
1740 | vert_from_glsl_shader = true; |
||
1741 | |||
1742 | if (!ctx->Shader.CurrentVertexProgram->LinkStatus) { |
||
1743 | _mesa_error(ctx, GL_INVALID_OPERATION, |
||
1744 | "%s(shader not linked)", where); |
||
1745 | return GL_FALSE; |
||
1746 | } |
||
1747 | #if 0 /* not normally enabled */ |
||
1748 | { |
||
1749 | char errMsg[100]; |
||
1750 | if (!_mesa_validate_shader_program(ctx, |
||
1751 | ctx->Shader.CurrentVertexProgram, |
||
1752 | errMsg)) { |
||
1753 | _mesa_warning(ctx, "Shader program %u is invalid: %s", |
||
1754 | ctx->Shader.CurrentVertexProgram->Name, errMsg); |
||
1755 | } |
||
1756 | } |
||
1757 | #endif |
||
1758 | } |
||
1759 | |||
1760 | if (ctx->Shader.CurrentGeometryProgram) { |
||
1761 | geom_from_glsl_shader = true; |
||
1762 | |||
1763 | if (!ctx->Shader.CurrentGeometryProgram->LinkStatus) { |
||
1764 | _mesa_error(ctx, GL_INVALID_OPERATION, |
||
1765 | "%s(shader not linked)", where); |
||
1766 | return GL_FALSE; |
||
1767 | } |
||
1768 | #if 0 /* not normally enabled */ |
||
1769 | { |
||
1770 | char errMsg[100]; |
||
1771 | if (!_mesa_validate_shader_program(ctx, |
||
1772 | ctx->Shader.CurrentGeometryProgram, |
||
1773 | errMsg)) { |
||
1774 | _mesa_warning(ctx, "Shader program %u is invalid: %s", |
||
1775 | ctx->Shader.CurrentGeometryProgram->Name, errMsg); |
||
1776 | } |
||
1777 | } |
||
1778 | #endif |
||
1779 | } |
||
1780 | |||
1781 | if (ctx->Shader.CurrentFragmentProgram) { |
||
1782 | frag_from_glsl_shader = true; |
||
1783 | |||
1784 | if (!ctx->Shader.CurrentFragmentProgram->LinkStatus) { |
||
1785 | _mesa_error(ctx, GL_INVALID_OPERATION, |
||
1786 | "%s(shader not linked)", where); |
||
1787 | return GL_FALSE; |
||
1788 | } |
||
1789 | #if 0 /* not normally enabled */ |
||
1790 | { |
||
1791 | char errMsg[100]; |
||
1792 | if (!_mesa_validate_shader_program(ctx, |
||
1793 | ctx->Shader.CurrentFragmentProgram, |
||
1794 | errMsg)) { |
||
1795 | _mesa_warning(ctx, "Shader program %u is invalid: %s", |
||
1796 | ctx->Shader.CurrentFragmentProgram->Name, errMsg); |
||
1797 | } |
||
1798 | } |
||
1799 | #endif |
||
1800 | } |
||
1801 | |||
1802 | /* Any shader stages that are not supplied by the GLSL shader and have |
||
1803 | * assembly shaders enabled must now be validated. |
||
1804 | */ |
||
1805 | if (!vert_from_glsl_shader |
||
1806 | && ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) { |
||
1807 | _mesa_error(ctx, GL_INVALID_OPERATION, |
||
1808 | "%s(vertex program not valid)", where); |
||
1809 | return GL_FALSE; |
||
1810 | } |
||
1811 | |||
1812 | /* FINISHME: If GL_NV_geometry_program4 is ever supported, the current |
||
1813 | * FINISHME: geometry program should validated here. |
||
1814 | */ |
||
1815 | (void) geom_from_glsl_shader; |
||
1816 | |||
1817 | if (!frag_from_glsl_shader) { |
||
1818 | if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) { |
||
1819 | _mesa_error(ctx, GL_INVALID_OPERATION, |
||
1820 | "%s(fragment program not valid)", where); |
||
1821 | return GL_FALSE; |
||
1822 | } |
||
1823 | |||
1824 | /* If drawing to integer-valued color buffers, there must be an |
||
1825 | * active fragment shader (GL_EXT_texture_integer). |
||
1826 | */ |
||
1827 | if (ctx->DrawBuffer && ctx->DrawBuffer->_IntegerColor) { |
||
1828 | _mesa_error(ctx, GL_INVALID_OPERATION, |
||
1829 | "%s(integer format but no fragment shader)", where); |
||
1830 | return GL_FALSE; |
||
1831 | } |
||
1832 | } |
||
1833 | |||
1834 | if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) { |
||
1835 | _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT, |
||
1836 | "%s(incomplete framebuffer)", where); |
||
1837 | return GL_FALSE; |
||
1838 | } |
||
1839 | |||
1840 | #ifdef DEBUG |
||
1841 | if (ctx->Shader.Flags & GLSL_LOG) { |
||
1842 | struct gl_shader_program *shProg[MESA_SHADER_TYPES]; |
||
1843 | gl_shader_type i; |
||
1844 | |||
1845 | shProg[MESA_SHADER_VERTEX] = ctx->Shader.CurrentVertexProgram; |
||
1846 | shProg[MESA_SHADER_GEOMETRY] = ctx->Shader.CurrentGeometryProgram; |
||
1847 | shProg[MESA_SHADER_FRAGMENT] = ctx->Shader.CurrentFragmentProgram; |
||
1848 | |||
1849 | for (i = 0; i < MESA_SHADER_TYPES; i++) { |
||
1850 | struct gl_shader *sh; |
||
1851 | |||
1852 | if (shProg[i] == NULL || shProg[i]->_Used |
||
1853 | || shProg[i]->_LinkedShaders[i] == NULL) |
||
1854 | continue; |
||
1855 | |||
1856 | /* This is the first time this shader is being used. |
||
1857 | * Append shader's constants/uniforms to log file. |
||
1858 | * |
||
1859 | * The logic is a little odd here. We only want to log data for each |
||
1860 | * shader target that will actually be used, and we only want to log |
||
1861 | * it once. It's possible to have a program bound to the vertex |
||
1862 | * shader target that also supplied a fragment shader. If that |
||
1863 | * program isn't also bound to the fragment shader target we don't |
||
1864 | * want to log its fragment data. |
||
1865 | */ |
||
1866 | sh = shProg[i]->_LinkedShaders[i]; |
||
1867 | switch (sh->Type) { |
||
1868 | case GL_VERTEX_SHADER: |
||
1869 | _mesa_append_uniforms_to_file(sh, &shProg[i]->VertexProgram->Base); |
||
1870 | break; |
||
1871 | |||
1872 | case GL_GEOMETRY_SHADER_ARB: |
||
1873 | _mesa_append_uniforms_to_file(sh, |
||
1874 | &shProg[i]->GeometryProgram->Base); |
||
1875 | break; |
||
1876 | |||
1877 | case GL_FRAGMENT_SHADER: |
||
1878 | _mesa_append_uniforms_to_file(sh, |
||
1879 | &shProg[i]->FragmentProgram->Base); |
||
1880 | break; |
||
1881 | } |
||
1882 | } |
||
1883 | |||
1884 | for (i = 0; i < MESA_SHADER_TYPES; i++) { |
||
1885 | if (shProg[i] != NULL) |
||
1886 | shProg[i]->_Used = GL_TRUE; |
||
1887 | } |
||
1888 | } |
||
1889 | #endif |
||
1890 | |||
1891 | return GL_TRUE; |
||
1892 | } |
||
1893 | |||
1894 | |||
1895 | /*@}*/>>>>>>>=>=>=>=>=>><>=>=>><>=>><>=>><>=>=>=>=>=>=>=>=>=>=>=>=>=>=>=>=>=>=>=>= |