projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'origin' into softpipe_0_1_branch
[mesa.git] / src / mesa / main / context.c
1 /**
2 * \file context.c
3 * Mesa context/visual/framebuffer management functions.
4 * \author Brian Paul
5 */
6
7 /*
8 * Mesa 3-D graphics library
9 * Version: 6.5
10 *
11 * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
12 *
13 * Permission is hereby granted, free of charge, to any person obtaining a
14 * copy of this software and associated documentation files (the "Software"),
15 * to deal in the Software without restriction, including without limitation
16 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
17 * and/or sell copies of the Software, and to permit persons to whom the
18 * Software is furnished to do so, subject to the following conditions:
19 *
20 * The above copyright notice and this permission notice shall be included
21 * in all copies or substantial portions of the Software.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
24 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
26 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
27 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
28 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 */
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 * <UL>
40 * <LI> Structures to represent most GL state </LI>
41 * <LI> State set/get functions </LI>
42 * <LI> Display lists </LI>
43 * <LI> Texture unit, object and image handling </LI>
44 * <LI> Matrix and attribute stacks </LI>
45 * </UL>
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 <b>Main page</b> link will display a summary of the module
62 * (this page).
63 *
64 * Selecting <b>Data Structures</b> will list all C structures.
65 *
66 * Selecting the <b>File List</b> 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 <b>Data Fields</b> link will display a list of all
71 * documented structure members.
72 *
73 * Selecting the <b>Globals</b> 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 "imports.h"
81 #include "accum.h"
82 #include "arrayobj.h"
83 #include "attrib.h"
84 #include "blend.h"
85 #include "buffers.h"
86 #include "bufferobj.h"
87 #include "colortab.h"
88 #include "context.h"
89 #include "debug.h"
90 #include "depth.h"
91 #include "dlist.h"
92 #include "eval.h"
93 #include "enums.h"
94 #include "extensions.h"
95 #include "fbobject.h"
96 #include "feedback.h"
97 #include "fog.h"
98 #include "framebuffer.h"
99 #include "get.h"
100 #include "histogram.h"
101 #include "hint.h"
102 #include "hash.h"
103 #include "light.h"
104 #include "lines.h"
105 #include "macros.h"
106 #include "matrix.h"
107 #include "pixel.h"
108 #include "points.h"
109 #include "polygon.h"
110 #include "queryobj.h"
111 #include "rastpos.h"
112 #include "simple_list.h"
113 #include "state.h"
114 #include "stencil.h"
115 #include "texcompress.h"
116 #include "teximage.h"
117 #include "texobj.h"
118 #include "texstate.h"
119 #include "mtypes.h"
120 #include "varray.h"
121 #include "version.h"
122 #include "vtxfmt.h"
123 #include "glapi/glthread.h"
124 #include "glapi/glapioffsets.h"
125 #if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
126 #include "shader/program.h"
127 #endif
128 #include "shader/shader_api.h"
129 #include "shader/atifragshader.h"
130 #if _HAVE_FULL_GL
131 #include "math/m_translate.h"
132 #include "math/m_matrix.h"
133 #include "math/m_xform.h"
134 #include "math/mathmod.h"
135 #endif
136
137 #ifdef USE_SPARC_ASM
138 #include "sparc/sparc.h"
139 #endif
140
141 #ifndef MESA_VERBOSE
142 int MESA_VERBOSE = 0;
143 #endif
144
145 #ifndef MESA_DEBUG_FLAGS
146 int MESA_DEBUG_FLAGS = 0;
147 #endif
148
149
150 /* ubyte -> float conversion */
151 GLfloat _mesa_ubyte_to_float_color_tab[256];
152
153 static void
154 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss );
155
156
157 /**
158 * Swap buffers notification callback.
159 *
160 * \param gc GL context.
161 *
162 * Called by window system just before swapping buffers.
163 * We have to finish any pending rendering.
164 */
165 void
166 _mesa_notifySwapBuffers(__GLcontext *gc)
167 {
168 FLUSH_VERTICES( gc, 0 );
169 }
170
171
172 /**********************************************************************/
173 /** \name GL Visual allocation/destruction */
174 /**********************************************************************/
175 /*@{*/
176
177 /**
178 * Allocates a GLvisual structure and initializes it via
179 * _mesa_initialize_visual().
180 *
181 * \param rgbFlag GL_TRUE for RGB(A) mode, GL_FALSE for Color Index mode.
182 * \param dbFlag double buffering
183 * \param stereoFlag stereo buffer
184 * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
185 * is acceptable but the actual depth type will be GLushort or GLuint as
186 * needed.
187 * \param stencilBits requested minimum bits per stencil buffer value
188 * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.
189 * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
190 * \param redBits number of bits per color component in frame buffer for RGB(A)
191 * mode. We always use 8 in core Mesa though.
192 * \param greenBits same as above.
193 * \param blueBits same as above.
194 * \param alphaBits same as above.
195 * \param numSamples not really used.
196 *
197 * \return pointer to new GLvisual or NULL if requested parameters can't be
198 * met.
199 *
200 * \note Need to add params for level and numAuxBuffers (at least)
201 */
202 GLvisual *
203 _mesa_create_visual( GLboolean rgbFlag,
204 GLboolean dbFlag,
205 GLboolean stereoFlag,
206 GLint redBits,
207 GLint greenBits,
208 GLint blueBits,
209 GLint alphaBits,
210 GLint indexBits,
211 GLint depthBits,
212 GLint stencilBits,
213 GLint accumRedBits,
214 GLint accumGreenBits,
215 GLint accumBlueBits,
216 GLint accumAlphaBits,
217 GLint numSamples )
218 {
219 GLvisual *vis = (GLvisual *) _mesa_calloc(sizeof(GLvisual));
220 if (vis) {
221 if (!_mesa_initialize_visual(vis, rgbFlag, dbFlag, stereoFlag,
222 redBits, greenBits, blueBits, alphaBits,
223 indexBits, depthBits, stencilBits,
224 accumRedBits, accumGreenBits,
225 accumBlueBits, accumAlphaBits,
226 numSamples)) {
227 _mesa_free(vis);
228 return NULL;
229 }
230 }
231 return vis;
232 }
233
234 /**
235 * Makes some sanity checks and fills in the fields of the
236 * GLvisual object with the given parameters. If the caller needs
237 * to set additional fields, he should just probably init the whole GLvisual
238 * object himself.
239 * \return GL_TRUE on success, or GL_FALSE on failure.
240 *
241 * \sa _mesa_create_visual() above for the parameter description.
242 */
243 GLboolean
244 _mesa_initialize_visual( GLvisual *vis,
245 GLboolean rgbFlag,
246 GLboolean dbFlag,
247 GLboolean stereoFlag,
248 GLint redBits,
249 GLint greenBits,
250 GLint blueBits,
251 GLint alphaBits,
252 GLint indexBits,
253 GLint depthBits,
254 GLint stencilBits,
255 GLint accumRedBits,
256 GLint accumGreenBits,
257 GLint accumBlueBits,
258 GLint accumAlphaBits,
259 GLint numSamples )
260 {
261 assert(vis);
262
263 if (depthBits < 0 || depthBits > 32) {
264 return GL_FALSE;
265 }
266 if (stencilBits < 0 || stencilBits > STENCIL_BITS) {
267 return GL_FALSE;
268 }
269 assert(accumRedBits >= 0);
270 assert(accumGreenBits >= 0);
271 assert(accumBlueBits >= 0);
272 assert(accumAlphaBits >= 0);
273
274 vis->rgbMode = rgbFlag;
275 vis->doubleBufferMode = dbFlag;
276 vis->stereoMode = stereoFlag;
277
278 vis->redBits = redBits;
279 vis->greenBits = greenBits;
280 vis->blueBits = blueBits;
281 vis->alphaBits = alphaBits;
282 vis->rgbBits = redBits + greenBits + blueBits;
283
284 vis->indexBits = indexBits;
285 vis->depthBits = depthBits;
286 vis->stencilBits = stencilBits;
287
288 vis->accumRedBits = accumRedBits;
289 vis->accumGreenBits = accumGreenBits;
290 vis->accumBlueBits = accumBlueBits;
291 vis->accumAlphaBits = accumAlphaBits;
292
293 vis->haveAccumBuffer = accumRedBits > 0;
294 vis->haveDepthBuffer = depthBits > 0;
295 vis->haveStencilBuffer = stencilBits > 0;
296
297 vis->numAuxBuffers = 0;
298 vis->level = 0;
299 vis->pixmapMode = 0;
300 vis->sampleBuffers = numSamples > 0 ? 1 : 0;
301 vis->samples = numSamples;
302
303 return GL_TRUE;
304 }
305
306
307 /**
308 * Destroy a visual and free its memory.
309 *
310 * \param vis visual.
311 *
312 * Frees the visual structure.
313 */
314 void
315 _mesa_destroy_visual( GLvisual *vis )
316 {
317 _mesa_free(vis);
318 }
319
320 /*@}*/
321
322
323 /**********************************************************************/
324 /** \name Context allocation, initialization, destroying
325 *
326 * The purpose of the most initialization functions here is to provide the
327 * default state values according to the OpenGL specification.
328 */
329 /**********************************************************************/
330 /*@{*/
331
332 /**
333 * One-time initialization mutex lock.
334 *
335 * \sa Used by one_time_init().
336 */
337 _glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
338
339 /**
340 * Calls all the various one-time-init functions in Mesa.
341 *
342 * While holding a global mutex lock, calls several initialization functions,
343 * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
344 * defined.
345 *
346 * \sa _math_init().
347 */
348 static void
349 one_time_init( GLcontext *ctx )
350 {
351 static GLboolean alreadyCalled = GL_FALSE;
352 (void) ctx;
353 _glthread_LOCK_MUTEX(OneTimeLock);
354 if (!alreadyCalled) {
355 GLuint i;
356
357 /* do some implementation tests */
358 assert( sizeof(GLbyte) == 1 );
359 assert( sizeof(GLubyte) == 1 );
360 assert( sizeof(GLshort) == 2 );
361 assert( sizeof(GLushort) == 2 );
362 assert( sizeof(GLint) == 4 );
363 assert( sizeof(GLuint) == 4 );
364
365 _mesa_init_sqrt_table();
366
367 #if _HAVE_FULL_GL
368 _math_init();
369
370 for (i = 0; i < 256; i++) {
371 _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
372 }
373 #endif
374
375 #ifdef USE_SPARC_ASM
376 _mesa_init_sparc_glapi_relocs();
377 #endif
378 if (_mesa_getenv("MESA_DEBUG")) {
379 _glapi_noop_enable_warnings(GL_TRUE);
380 _glapi_set_warning_func( (_glapi_warning_func) _mesa_warning );
381 }
382 else {
383 _glapi_noop_enable_warnings(GL_FALSE);
384 }
385
386 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
387 _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
388 MESA_VERSION_STRING, __DATE__, __TIME__);
389 #endif
390
391 alreadyCalled = GL_TRUE;
392 }
393 _glthread_UNLOCK_MUTEX(OneTimeLock);
394 }
395
396
397 /**
398 * Allocate and initialize a shared context state structure.
399 * Initializes the display list, texture objects and vertex programs hash
400 * tables, allocates the texture objects. If it runs out of memory, frees
401 * everything already allocated before returning NULL.
402 *
403 * \return pointer to a gl_shared_state structure on success, or NULL on
404 * failure.
405 */
406 static GLboolean
407 alloc_shared_state( GLcontext *ctx )
408 {
409 struct gl_shared_state *ss = CALLOC_STRUCT(gl_shared_state);
410 if (!ss)
411 return GL_FALSE;
412
413 ctx->Shared = ss;
414
415 _glthread_INIT_MUTEX(ss->Mutex);
416
417 ss->DisplayList = _mesa_NewHashTable();
418 ss->TexObjects = _mesa_NewHashTable();
419 #if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
420 ss->Programs = _mesa_NewHashTable();
421 #endif
422
423 #if FEATURE_ARB_vertex_program
424 ss->DefaultVertexProgram = ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
425 if (!ss->DefaultVertexProgram)
426 goto cleanup;
427 #endif
428 #if FEATURE_ARB_fragment_program
429 ss->DefaultFragmentProgram = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
430 if (!ss->DefaultFragmentProgram)
431 goto cleanup;
432 #endif
433 #if FEATURE_ATI_fragment_shader
434 ss->ATIShaders = _mesa_NewHashTable();
435 ss->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0);
436 if (!ss->DefaultFragmentShader)
437 goto cleanup;
438 #endif
439
440 #if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
441 ss->BufferObjects = _mesa_NewHashTable();
442 #endif
443
444 ss->ArrayObjects = _mesa_NewHashTable();
445
446 #if FEATURE_ARB_shader_objects
447 ss->ShaderObjects = _mesa_NewHashTable();
448 #endif
449
450 ss->Default1D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D);
451 if (!ss->Default1D)
452 goto cleanup;
453
454 ss->Default2D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D);
455 if (!ss->Default2D)
456 goto cleanup;
457
458 ss->Default3D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_3D);
459 if (!ss->Default3D)
460 goto cleanup;
461
462 ss->DefaultCubeMap = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_CUBE_MAP_ARB);
463 if (!ss->DefaultCubeMap)
464 goto cleanup;
465
466 ss->DefaultRect = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_RECTANGLE_NV);
467 if (!ss->DefaultRect)
468 goto cleanup;
469
470 ss->Default1DArray = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D_ARRAY_EXT);
471 if (!ss->Default1DArray)
472 goto cleanup;
473
474 ss->Default2DArray = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D_ARRAY_EXT);
475 if (!ss->Default2DArray)
476 goto cleanup;
477
478 /* Effectively bind the default textures to all texture units */
479 ss->Default1D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
480 ss->Default2D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
481 ss->Default3D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
482 ss->DefaultCubeMap->RefCount += MAX_TEXTURE_IMAGE_UNITS;
483 ss->DefaultRect->RefCount += MAX_TEXTURE_IMAGE_UNITS;
484 ss->Default1DArray->RefCount += MAX_TEXTURE_IMAGE_UNITS;
485 ss->Default2DArray->RefCount += MAX_TEXTURE_IMAGE_UNITS;
486
487 _glthread_INIT_MUTEX(ss->TexMutex);
488 ss->TextureStateStamp = 0;
489
490
491 #if FEATURE_EXT_framebuffer_object
492 ss->FrameBuffers = _mesa_NewHashTable();
493 if (!ss->FrameBuffers)
494 goto cleanup;
495 ss->RenderBuffers = _mesa_NewHashTable();
496 if (!ss->RenderBuffers)
497 goto cleanup;
498 #endif
499
500
501 return GL_TRUE;
502
503 cleanup:
504 /* Ran out of memory at some point. Free everything and return NULL */
505 if (ss->DisplayList)
506 _mesa_DeleteHashTable(ss->DisplayList);
507 if (ss->TexObjects)
508 _mesa_DeleteHashTable(ss->TexObjects);
509 #if FEATURE_NV_vertex_program
510 if (ss->Programs)
511 _mesa_DeleteHashTable(ss->Programs);
512 #endif
513 #if FEATURE_ARB_vertex_program
514 if (ss->DefaultVertexProgram)
515 ctx->Driver.DeleteProgram(ctx, ss->DefaultVertexProgram);
516 #endif
517 #if FEATURE_ARB_fragment_program
518 if (ss->DefaultFragmentProgram)
519 ctx->Driver.DeleteProgram(ctx, ss->DefaultFragmentProgram);
520 #endif
521 #if FEATURE_ATI_fragment_shader
522 if (ss->DefaultFragmentShader)
523 _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
524 #endif
525 #if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
526 if (ss->BufferObjects)
527 _mesa_DeleteHashTable(ss->BufferObjects);
528 #endif
529
530 if (ss->ArrayObjects)
531 _mesa_DeleteHashTable (ss->ArrayObjects);
532
533 #if FEATURE_ARB_shader_objects
534 if (ss->ShaderObjects)
535 _mesa_DeleteHashTable (ss->ShaderObjects);
536 #endif
537
538 #if FEATURE_EXT_framebuffer_object
539 if (ss->FrameBuffers)
540 _mesa_DeleteHashTable(ss->FrameBuffers);
541 if (ss->RenderBuffers)
542 _mesa_DeleteHashTable(ss->RenderBuffers);
543 #endif
544
545 if (ss->Default1D)
546 (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D);
547 if (ss->Default2D)
548 (*ctx->Driver.DeleteTexture)(ctx, ss->Default2D);
549 if (ss->Default3D)
550 (*ctx->Driver.DeleteTexture)(ctx, ss->Default3D);
551 if (ss->DefaultCubeMap)
552 (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap);
553 if (ss->DefaultRect)
554 (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect);
555 if (ss)
556 _mesa_free(ss);
557 return GL_FALSE;
558 }
559
560
561 /**
562 * Callback for deleting a display list. Called by _mesa_HashDeleteAll().
563 */
564 static void
565 delete_displaylist_cb(GLuint id, void *data, void *userData)
566 {
567 struct mesa_display_list *list = (struct mesa_display_list *) data;
568 GLcontext *ctx = (GLcontext *) userData;
569 _mesa_delete_list(ctx, list);
570 }
571
572 /**
573 * Callback for deleting a texture object. Called by _mesa_HashDeleteAll().
574 */
575 static void
576 delete_texture_cb(GLuint id, void *data, void *userData)
577 {
578 struct gl_texture_object *texObj = (struct gl_texture_object *) data;
579 GLcontext *ctx = (GLcontext *) userData;
580 ctx->Driver.DeleteTexture(ctx, texObj);
581 }
582
583 /**
584 * Callback for deleting a program object. Called by _mesa_HashDeleteAll().
585 */
586 static void
587 delete_program_cb(GLuint id, void *data, void *userData)
588 {
589 struct gl_program *prog = (struct gl_program *) data;
590 GLcontext *ctx = (GLcontext *) userData;
591 ctx->Driver.DeleteProgram(ctx, prog);
592 }
593
594 /**
595 * Callback for deleting an ATI fragment shader object.
596 * Called by _mesa_HashDeleteAll().
597 */
598 static void
599 delete_fragshader_cb(GLuint id, void *data, void *userData)
600 {
601 struct ati_fragment_shader *shader = (struct ati_fragment_shader *) data;
602 GLcontext *ctx = (GLcontext *) userData;
603 _mesa_delete_ati_fragment_shader(ctx, shader);
604 }
605
606 /**
607 * Callback for deleting a buffer object. Called by _mesa_HashDeleteAll().
608 */
609 static void
610 delete_bufferobj_cb(GLuint id, void *data, void *userData)
611 {
612 struct gl_buffer_object *bufObj = (struct gl_buffer_object *) data;
613 GLcontext *ctx = (GLcontext *) userData;
614 ctx->Driver.DeleteBuffer(ctx, bufObj);
615 }
616
617 /**
618 * Callback for deleting an array object. Called by _mesa_HashDeleteAll().
619 */
620 static void
621 delete_arrayobj_cb(GLuint id, void *data, void *userData)
622 {
623 struct gl_array_object *arrayObj = (struct gl_array_object *) data;
624 GLcontext *ctx = (GLcontext *) userData;
625 _mesa_delete_array_object(ctx, arrayObj);
626 }
627
628 /**
629 * Callback for deleting shader and shader programs objects.
630 * Called by _mesa_HashDeleteAll().
631 */
632 static void
633 delete_shader_cb(GLuint id, void *data, void *userData)
634 {
635 GLcontext *ctx = (GLcontext *) userData;
636 struct gl_shader *sh = (struct gl_shader *) data;
637 if (sh->Type == GL_FRAGMENT_SHADER || sh->Type == GL_VERTEX_SHADER) {
638 _mesa_free_shader(ctx, sh);
639 }
640 else {
641 struct gl_shader_program *shProg = (struct gl_shader_program *) data;
642 ASSERT(shProg->Type == GL_SHADER_PROGRAM_MESA);
643 _mesa_free_shader_program(ctx, shProg);
644 }
645 }
646
647
648 /**
649 * Deallocate a shared state object and all children structures.
650 *
651 * \param ctx GL context.
652 * \param ss shared state pointer.
653 *
654 * Frees the display lists, the texture objects (calling the driver texture
655 * deletion callback to free its private data) and the vertex programs, as well
656 * as their hash tables.
657 *
658 * \sa alloc_shared_state().
659 */
660 static void
661 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
662 {
663 /*
664 * Free display lists
665 */
666 _mesa_HashDeleteAll(ss->DisplayList, delete_displaylist_cb, ctx);
667 _mesa_DeleteHashTable(ss->DisplayList);
668
669 /*
670 * Free texture objects
671 */
672 ASSERT(ctx->Driver.DeleteTexture);
673 /* the default textures */
674 ctx->Driver.DeleteTexture(ctx, ss->Default1D);
675 ctx->Driver.DeleteTexture(ctx, ss->Default2D);
676 ctx->Driver.DeleteTexture(ctx, ss->Default3D);
677 ctx->Driver.DeleteTexture(ctx, ss->DefaultCubeMap);
678 ctx->Driver.DeleteTexture(ctx, ss->DefaultRect);
679 /* all other textures */
680 _mesa_HashDeleteAll(ss->TexObjects, delete_texture_cb, ctx);
681 _mesa_DeleteHashTable(ss->TexObjects);
682
683 #if defined(FEATURE_NV_vertex_program) || defined(FEATURE_NV_fragment_program)
684 _mesa_HashDeleteAll(ss->Programs, delete_program_cb, ctx);
685 _mesa_DeleteHashTable(ss->Programs);
686 #endif
687 #if FEATURE_ARB_vertex_program
688 _mesa_delete_program(ctx, ss->DefaultVertexProgram);
689 #endif
690 #if FEATURE_ARB_fragment_program
691 _mesa_delete_program(ctx, ss->DefaultFragmentProgram);
692 #endif
693
694 #if FEATURE_ATI_fragment_shader
695 _mesa_HashDeleteAll(ss->ATIShaders, delete_fragshader_cb, ctx);
696 _mesa_DeleteHashTable(ss->ATIShaders);
697 _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
698 #endif
699
700 #if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
701 _mesa_HashDeleteAll(ss->BufferObjects, delete_bufferobj_cb, ctx);
702 _mesa_DeleteHashTable(ss->BufferObjects);
703 #endif
704
705 _mesa_HashDeleteAll(ss->ArrayObjects, delete_arrayobj_cb, ctx);
706 _mesa_DeleteHashTable(ss->ArrayObjects);
707
708 #if FEATURE_ARB_shader_objects
709 _mesa_HashDeleteAll(ss->ShaderObjects, delete_shader_cb, ctx);
710 _mesa_DeleteHashTable(ss->ShaderObjects);
711 #endif
712
713 #if FEATURE_EXT_framebuffer_object
714 _mesa_DeleteHashTable(ss->FrameBuffers);
715 _mesa_DeleteHashTable(ss->RenderBuffers);
716 #endif
717
718 _glthread_DESTROY_MUTEX(ss->Mutex);
719
720 _mesa_free(ss);
721 }
722
723
724 /**
725 * Initialize fields of gl_current_attrib (aka ctx->Current.*)
726 */
727 static void
728 _mesa_init_current(GLcontext *ctx)
729 {
730 GLuint i;
731
732 /* Init all to (0,0,0,1) */
733 for (i = 0; i < VERT_ATTRIB_MAX; i++) {
734 ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
735 }
736
737 /* redo special cases: */
738 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 1.0 );
739 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
740 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
741 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
742 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
743 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
744 }
745
746
747 /**
748 * Init vertex/fragment program native limits from logical limits.
749 */
750 static void
751 init_natives(struct gl_program_constants *prog)
752 {
753 prog->MaxNativeInstructions = prog->MaxInstructions;
754 prog->MaxNativeAluInstructions = prog->MaxAluInstructions;
755 prog->MaxNativeTexInstructions = prog->MaxTexInstructions;
756 prog->MaxNativeTexIndirections = prog->MaxTexIndirections;
757 prog->MaxNativeAttribs = prog->MaxAttribs;
758 prog->MaxNativeTemps = prog->MaxTemps;
759 prog->MaxNativeAddressRegs = prog->MaxAddressRegs;
760 prog->MaxNativeParameters = prog->MaxParameters;
761 }
762
763
764 /**
765 * Initialize fields of gl_constants (aka ctx->Const.*).
766 * Use defaults from config.h. The device drivers will often override
767 * some of these values (such as number of texture units).
768 */
769 static void
770 _mesa_init_constants(GLcontext *ctx)
771 {
772 assert(ctx);
773
774 assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
775 assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
776
777 assert(MAX_TEXTURE_UNITS >= MAX_TEXTURE_COORD_UNITS);
778 assert(MAX_TEXTURE_UNITS >= MAX_TEXTURE_IMAGE_UNITS);
779
780 /* Constants, may be overriden (usually only reduced) by device drivers */
781 ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
782 ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
783 ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
784 ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
785 ctx->Const.MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
786 ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
787 ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
788 ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,
789 ctx->Const.MaxTextureImageUnits);
790 ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
791 ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
792 ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
793 ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
794 ctx->Const.MinPointSize = MIN_POINT_SIZE;
795 ctx->Const.MaxPointSize = MAX_POINT_SIZE;
796 ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
797 ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
798 ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
799 ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
800 ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
801 ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
802 ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
803 ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
804 ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
805 ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
806 ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
807 ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
808 ctx->Const.MaxLights = MAX_LIGHTS;
809 ctx->Const.MaxShininess = 128.0;
810 ctx->Const.MaxSpotExponent = 128.0;
811 ctx->Const.MaxViewportWidth = MAX_WIDTH;
812 ctx->Const.MaxViewportHeight = MAX_HEIGHT;
813 #if FEATURE_ARB_vertex_program
814 ctx->Const.VertexProgram.MaxInstructions = MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS;
815 ctx->Const.VertexProgram.MaxAluInstructions = 0;
816 ctx->Const.VertexProgram.MaxTexInstructions = 0;
817 ctx->Const.VertexProgram.MaxTexIndirections = 0;
818 ctx->Const.VertexProgram.MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
819 ctx->Const.VertexProgram.MaxTemps = MAX_PROGRAM_TEMPS;
820 ctx->Const.VertexProgram.MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
821 ctx->Const.VertexProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
822 ctx->Const.VertexProgram.MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
823 ctx->Const.VertexProgram.MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
824 ctx->Const.VertexProgram.MaxUniformComponents = 4 * MAX_UNIFORMS;
825 init_natives(&ctx->Const.VertexProgram);
826 #endif
827
828 #if FEATURE_ARB_fragment_program
829 ctx->Const.FragmentProgram.MaxInstructions = MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS;
830 ctx->Const.FragmentProgram.MaxAluInstructions = MAX_FRAGMENT_PROGRAM_ALU_INSTRUCTIONS;
831 ctx->Const.FragmentProgram.MaxTexInstructions = MAX_FRAGMENT_PROGRAM_TEX_INSTRUCTIONS;
832 ctx->Const.FragmentProgram.MaxTexIndirections = MAX_FRAGMENT_PROGRAM_TEX_INDIRECTIONS;
833 ctx->Const.FragmentProgram.MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
834 ctx->Const.FragmentProgram.MaxTemps = MAX_PROGRAM_TEMPS;
835 ctx->Const.FragmentProgram.MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
836 ctx->Const.FragmentProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
837 ctx->Const.FragmentProgram.MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
838 ctx->Const.FragmentProgram.MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
839 ctx->Const.FragmentProgram.MaxUniformComponents = 4 * MAX_UNIFORMS;
840 init_natives(&ctx->Const.FragmentProgram);
841 #endif
842 ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
843 ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
844
845 /* CheckArrayBounds is overriden by drivers/x11 for X server */
846 ctx->Const.CheckArrayBounds = GL_FALSE;
847
848 /* GL_ARB_draw_buffers */
849 ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
850
851 /* GL_OES_read_format */
852 ctx->Const.ColorReadFormat = GL_RGBA;
853 ctx->Const.ColorReadType = GL_UNSIGNED_BYTE;
854
855 #if FEATURE_EXT_framebuffer_object
856 ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
857 ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
858 #endif
859
860 #if FEATURE_ARB_vertex_shader
861 ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
862 ctx->Const.MaxVarying = MAX_VARYING;
863 #endif
864
865 /* sanity checks */
866 ASSERT(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,
867 ctx->Const.MaxTextureCoordUnits));
868 ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
869 ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
870
871 ASSERT(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
872 ASSERT(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
873 ASSERT(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);
874 ASSERT(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);
875 }
876
877
878 /**
879 * Do some sanity checks on the limits/constants for the given context.
880 * Only called the first time a context is bound.
881 */
882 static void
883 check_context_limits(GLcontext *ctx)
884 {
885 /* Many context limits/constants are limited by the size of
886 * internal arrays.
887 */
888 assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
889 assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
890 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
891 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
892
893 assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);
894 assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);
895
896 /* make sure largest texture image is <= MAX_WIDTH in size */
897 assert((1 << (ctx->Const.MaxTextureLevels -1 )) <= MAX_WIDTH);
898 assert((1 << (ctx->Const.MaxCubeTextureLevels -1 )) <= MAX_WIDTH);
899 assert((1 << (ctx->Const.Max3DTextureLevels -1 )) <= MAX_WIDTH);
900
901 assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
902
903 /* XXX probably add more tests */
904 }
905
906
907 /**
908 * Initialize the attribute groups in a GL context.
909 *
910 * \param ctx GL context.
911 *
912 * Initializes all the attributes, calling the respective <tt>init*</tt>
913 * functions for the more complex data structures.
914 */
915 static GLboolean
916 init_attrib_groups(GLcontext *ctx)
917 {
918 assert(ctx);
919
920 /* Constants */
921 _mesa_init_constants( ctx );
922
923 /* Extensions */
924 _mesa_init_extensions( ctx );
925
926 /* Attribute Groups */
927 _mesa_init_accum( ctx );
928 _mesa_init_attrib( ctx );
929 _mesa_init_buffer_objects( ctx );
930 _mesa_init_color( ctx );
931 _mesa_init_colortables( ctx );
932 _mesa_init_current( ctx );
933 _mesa_init_depth( ctx );
934 _mesa_init_debug( ctx );
935 _mesa_init_display_list( ctx );
936 _mesa_init_eval( ctx );
937 _mesa_init_feedback( ctx );
938 _mesa_init_fog( ctx );
939 _mesa_init_histogram( ctx );
940 _mesa_init_hint( ctx );
941 _mesa_init_line( ctx );
942 _mesa_init_lighting( ctx );
943 _mesa_init_matrix( ctx );
944 _mesa_init_multisample( ctx );
945 _mesa_init_pixel( ctx );
946 _mesa_init_point( ctx );
947 _mesa_init_polygon( ctx );
948 _mesa_init_program( ctx );
949 _mesa_init_query( ctx );
950 _mesa_init_rastpos( ctx );
951 _mesa_init_scissor( ctx );
952 _mesa_init_shader_state( ctx );
953 _mesa_init_stencil( ctx );
954 _mesa_init_transform( ctx );
955 _mesa_init_varray( ctx );
956 _mesa_init_viewport( ctx );
957
958 if (!_mesa_init_texture( ctx ))
959 return GL_FALSE;
960
961 _mesa_init_texture_s3tc( ctx );
962 _mesa_init_texture_fxt1( ctx );
963
964 /* Miscellaneous */
965 ctx->NewState = _NEW_ALL;
966 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
967 ctx->_Facing = 0;
968
969 return GL_TRUE;
970 }
971
972
973 /**
974 * This is the default function we plug into all dispatch table slots
975 * This helps prevents a segfault when someone calls a GL function without
976 * first checking if the extension's supported.
977 */
978 static int
979 generic_nop(void)
980 {
981 _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)");
982 return 0;
983 }
984
985
986 /**
987 * Allocate and initialize a new dispatch table.
988 */
989 static struct _glapi_table *
990 alloc_dispatch_table(void)
991 {
992 /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
993 * In practice, this'll be the same for stand-alone Mesa. But for DRI
994 * Mesa we do this to accomodate different versions of libGL and various
995 * DRI drivers.
996 */
997 GLint numEntries = MAX2(_glapi_get_dispatch_table_size(),
998 sizeof(struct _glapi_table) / sizeof(_glapi_proc));
999 struct _glapi_table *table =
1000 (struct _glapi_table *) _mesa_malloc(numEntries * sizeof(_glapi_proc));
1001 if (table) {
1002 _glapi_proc *entry = (_glapi_proc *) table;
1003 GLint i;
1004 for (i = 0; i < numEntries; i++) {
1005 entry[i] = (_glapi_proc) generic_nop;
1006 }
1007 }
1008 return table;
1009 }
1010
1011
1012 /**
1013 * Initialize a GLcontext struct (rendering context).
1014 *
1015 * This includes allocating all the other structs and arrays which hang off of
1016 * the context by pointers.
1017 * Note that the driver needs to pass in its dd_function_table here since
1018 * we need to at least call driverFunctions->NewTextureObject to create the
1019 * default texture objects.
1020 *
1021 * Called by _mesa_create_context().
1022 *
1023 * Performs the imports and exports callback tables initialization, and
1024 * miscellaneous one-time initializations. If no shared context is supplied one
1025 * is allocated, and increase its reference count. Setups the GL API dispatch
1026 * tables. Initialize the TNL module. Sets the maximum Z buffer depth.
1027 * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1028 * for debug flags.
1029 *
1030 * \param ctx the context to initialize
1031 * \param visual describes the visual attributes for this context
1032 * \param share_list points to context to share textures, display lists,
1033 * etc with, or NULL
1034 * \param driverFunctions table of device driver functions for this context
1035 * to use
1036 * \param driverContext pointer to driver-specific context data
1037 */
1038 GLboolean
1039 _mesa_initialize_context(GLcontext *ctx,
1040 const GLvisual *visual,
1041 GLcontext *share_list,
1042 const struct dd_function_table *driverFunctions,
1043 void *driverContext)
1044 {
1045 ASSERT(driverContext);
1046 assert(driverFunctions->NewTextureObject);
1047 assert(driverFunctions->FreeTexImageData);
1048
1049 /* misc one-time initializations */
1050 one_time_init(ctx);
1051
1052 ctx->Visual = *visual;
1053 ctx->DrawBuffer = NULL;
1054 ctx->ReadBuffer = NULL;
1055 ctx->WinSysDrawBuffer = NULL;
1056 ctx->WinSysReadBuffer = NULL;
1057
1058 /* Plug in driver functions and context pointer here.
1059 * This is important because when we call alloc_shared_state() below
1060 * we'll call ctx->Driver.NewTextureObject() to create the default
1061 * textures.
1062 */
1063 ctx->Driver = *driverFunctions;
1064 ctx->DriverCtx = driverContext;
1065
1066 if (share_list) {
1067 /* share state with another context */
1068 ctx->Shared = share_list->Shared;
1069 }
1070 else {
1071 /* allocate new, unshared state */
1072 if (!alloc_shared_state( ctx )) {
1073 return GL_FALSE;
1074 }
1075 }
1076 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1077 ctx->Shared->RefCount++;
1078 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1079
1080 if (!init_attrib_groups( ctx )) {
1081 free_shared_state(ctx, ctx->Shared);
1082 return GL_FALSE;
1083 }
1084
1085 /* setup the API dispatch tables */
1086 ctx->Exec = alloc_dispatch_table();
1087 ctx->Save = alloc_dispatch_table();
1088 if (!ctx->Exec || !ctx->Save) {
1089 free_shared_state(ctx, ctx->Shared);
1090 if (ctx->Exec)
1091 _mesa_free(ctx->Exec);
1092 }
1093 _mesa_init_exec_table(ctx->Exec);
1094 ctx->CurrentDispatch = ctx->Exec;
1095 #if _HAVE_FULL_GL
1096 _mesa_init_dlist_table(ctx->Save);
1097 _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
1098 /* Neutral tnl module stuff */
1099 _mesa_init_exec_vtxfmt( ctx );
1100 ctx->TnlModule.Current = NULL;
1101 ctx->TnlModule.SwapCount = 0;
1102 #endif
1103
1104 ctx->FragmentProgram._MaintainTexEnvProgram
1105 = (_mesa_getenv("MESA_TEX_PROG") != NULL);
1106 ctx->FragmentProgram._UseTexEnvProgram = ctx->FragmentProgram._MaintainTexEnvProgram;
1107
1108 ctx->VertexProgram._MaintainTnlProgram
1109 = (_mesa_getenv("MESA_TNL_PROG") != NULL);
1110 if (ctx->VertexProgram._MaintainTnlProgram) {
1111 /* this is required... */
1112 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1113 }
1114
1115 ctx->FirstTimeCurrent = GL_TRUE;
1116
1117 return GL_TRUE;
1118 }
1119
1120
1121 /**
1122 * Allocate and initialize a GLcontext structure.
1123 * Note that the driver needs to pass in its dd_function_table here since
1124 * we need to at least call driverFunctions->NewTextureObject to initialize
1125 * the rendering context.
1126 *
1127 * \param visual a GLvisual pointer (we copy the struct contents)
1128 * \param share_list another context to share display lists with or NULL
1129 * \param driverFunctions points to the dd_function_table into which the
1130 * driver has plugged in all its special functions.
1131 * \param driverCtx points to the device driver's private context state
1132 *
1133 * \return pointer to a new __GLcontextRec or NULL if error.
1134 */
1135 GLcontext *
1136 _mesa_create_context(const GLvisual *visual,
1137 GLcontext *share_list,
1138 const struct dd_function_table *driverFunctions,
1139 void *driverContext)
1140 {
1141 GLcontext *ctx;
1142
1143 ASSERT(visual);
1144 ASSERT(driverContext);
1145
1146 ctx = (GLcontext *) _mesa_calloc(sizeof(GLcontext));
1147 if (!ctx)
1148 return NULL;
1149
1150 if (_mesa_initialize_context(ctx, visual, share_list,
1151 driverFunctions, driverContext)) {
1152 return ctx;
1153 }
1154 else {
1155 _mesa_free(ctx);
1156 return NULL;
1157 }
1158 }
1159
1160
1161 /**
1162 * Free the data associated with the given context.
1163 *
1164 * But doesn't free the GLcontext struct itself.
1165 *
1166 * \sa _mesa_initialize_context() and init_attrib_groups().
1167 */
1168 void
1169 _mesa_free_context_data( GLcontext *ctx )
1170 {
1171 /* if we're destroying the current context, unbind it first */
1172 if (ctx == _mesa_get_current_context()) {
1173 _mesa_make_current(NULL, NULL, NULL);
1174 }
1175 else {
1176 /* unreference WinSysDraw/Read buffers */
1177 _mesa_unreference_framebuffer(&ctx->WinSysDrawBuffer);
1178 _mesa_unreference_framebuffer(&ctx->WinSysReadBuffer);
1179 _mesa_unreference_framebuffer(&ctx->DrawBuffer);
1180 _mesa_unreference_framebuffer(&ctx->ReadBuffer);
1181 }
1182
1183 _mesa_free_lighting_data( ctx );
1184 _mesa_free_eval_data( ctx );
1185 _mesa_free_texture_data( ctx );
1186 _mesa_free_matrix_data( ctx );
1187 _mesa_free_viewport_data( ctx );
1188 _mesa_free_colortables_data( ctx );
1189 _mesa_free_program_data(ctx);
1190 _mesa_free_shader_state(ctx);
1191 _mesa_free_query_data(ctx);
1192
1193 #if FEATURE_ARB_vertex_buffer_object
1194 _mesa_delete_buffer_object(ctx, ctx->Array.NullBufferObj);
1195 #endif
1196 _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);
1197
1198 /* free dispatch tables */
1199 _mesa_free(ctx->Exec);
1200 _mesa_free(ctx->Save);
1201
1202 /* Shared context state (display lists, textures, etc) */
1203 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1204 ctx->Shared->RefCount--;
1205 assert(ctx->Shared->RefCount >= 0);
1206 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1207 if (ctx->Shared->RefCount == 0) {
1208 /* free shared state */
1209 free_shared_state( ctx, ctx->Shared );
1210 }
1211
1212 if (ctx->Extensions.String)
1213 _mesa_free((void *) ctx->Extensions.String);
1214 }
1215
1216
1217 /**
1218 * Destroy a GLcontext structure.
1219 *
1220 * \param ctx GL context.
1221 *
1222 * Calls _mesa_free_context_data() and frees the GLcontext structure itself.
1223 */
1224 void
1225 _mesa_destroy_context( GLcontext *ctx )
1226 {
1227 if (ctx) {
1228 _mesa_free_context_data(ctx);
1229 _mesa_free( (void *) ctx );
1230 }
1231 }
1232
1233
1234 #if _HAVE_FULL_GL
1235 /**
1236 * Copy attribute groups from one context to another.
1237 *
1238 * \param src source context
1239 * \param dst destination context
1240 * \param mask bitwise OR of GL_*_BIT flags
1241 *
1242 * According to the bits specified in \p mask, copies the corresponding
1243 * attributes from \p src into \p dst. For many of the attributes a simple \c
1244 * memcpy is not enough due to the existence of internal pointers in their data
1245 * structures.
1246 */
1247 void
1248 _mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1249 {
1250 if (mask & GL_ACCUM_BUFFER_BIT) {
1251 /* OK to memcpy */
1252 dst->Accum = src->Accum;
1253 }
1254 if (mask & GL_COLOR_BUFFER_BIT) {
1255 /* OK to memcpy */
1256 dst->Color = src->Color;
1257 }
1258 if (mask & GL_CURRENT_BIT) {
1259 /* OK to memcpy */
1260 dst->Current = src->Current;
1261 }
1262 if (mask & GL_DEPTH_BUFFER_BIT) {
1263 /* OK to memcpy */
1264 dst->Depth = src->Depth;
1265 }
1266 if (mask & GL_ENABLE_BIT) {
1267 /* no op */
1268 }
1269 if (mask & GL_EVAL_BIT) {
1270 /* OK to memcpy */
1271 dst->Eval = src->Eval;
1272 }
1273 if (mask & GL_FOG_BIT) {
1274 /* OK to memcpy */
1275 dst->Fog = src->Fog;
1276 }
1277 if (mask & GL_HINT_BIT) {
1278 /* OK to memcpy */
1279 dst->Hint = src->Hint;
1280 }
1281 if (mask & GL_LIGHTING_BIT) {
1282 GLuint i;
1283 /* begin with memcpy */
1284 dst->Light = src->Light;
1285 /* fixup linked lists to prevent pointer insanity */
1286 make_empty_list( &(dst->Light.EnabledList) );
1287 for (i = 0; i < MAX_LIGHTS; i++) {
1288 if (dst->Light.Light[i].Enabled) {
1289 insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
1290 }
1291 }
1292 }
1293 if (mask & GL_LINE_BIT) {
1294 /* OK to memcpy */
1295 dst->Line = src->Line;
1296 }
1297 if (mask & GL_LIST_BIT) {
1298 /* OK to memcpy */
1299 dst->List = src->List;
1300 }
1301 if (mask & GL_PIXEL_MODE_BIT) {
1302 /* OK to memcpy */
1303 dst->Pixel = src->Pixel;
1304 }
1305 if (mask & GL_POINT_BIT) {
1306 /* OK to memcpy */
1307 dst->Point = src->Point;
1308 }
1309 if (mask & GL_POLYGON_BIT) {
1310 /* OK to memcpy */
1311 dst->Polygon = src->Polygon;
1312 }
1313 if (mask & GL_POLYGON_STIPPLE_BIT) {
1314 /* Use loop instead of MEMCPY due to problem with Portland Group's
1315 * C compiler. Reported by John Stone.
1316 */
1317 GLuint i;
1318 for (i = 0; i < 32; i++) {
1319 dst->PolygonStipple[i] = src->PolygonStipple[i];
1320 }
1321 }
1322 if (mask & GL_SCISSOR_BIT) {
1323 /* OK to memcpy */
1324 dst->Scissor = src->Scissor;
1325 }
1326 if (mask & GL_STENCIL_BUFFER_BIT) {
1327 /* OK to memcpy */
1328 dst->Stencil = src->Stencil;
1329 }
1330 if (mask & GL_TEXTURE_BIT) {
1331 /* Cannot memcpy because of pointers */
1332 _mesa_copy_texture_state(src, dst);
1333 }
1334 if (mask & GL_TRANSFORM_BIT) {
1335 /* OK to memcpy */
1336 dst->Transform = src->Transform;
1337 }
1338 if (mask & GL_VIEWPORT_BIT) {
1339 /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
1340 dst->Viewport.X = src->Viewport.X;
1341 dst->Viewport.Y = src->Viewport.Y;
1342 dst->Viewport.Width = src->Viewport.Width;
1343 dst->Viewport.Height = src->Viewport.Height;
1344 dst->Viewport.Near = src->Viewport.Near;
1345 dst->Viewport.Far = src->Viewport.Far;
1346 _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
1347 }
1348
1349 /* XXX FIXME: Call callbacks?
1350 */
1351 dst->NewState = _NEW_ALL;
1352 }
1353 #endif
1354
1355
1356 /**
1357 * Check if the given context can render into the given framebuffer
1358 * by checking visual attributes.
1359 *
1360 * Most of these tests could go away because Mesa is now pretty flexible
1361 * in terms of mixing rendering contexts with framebuffers. As long
1362 * as RGB vs. CI mode agree, we're probably good.
1363 *
1364 * \return GL_TRUE if compatible, GL_FALSE otherwise.
1365 */
1366 static GLboolean
1367 check_compatible(const GLcontext *ctx, const GLframebuffer *buffer)
1368 {
1369 const GLvisual *ctxvis = &ctx->Visual;
1370 const GLvisual *bufvis = &buffer->Visual;
1371
1372 if (ctxvis == bufvis)
1373 return GL_TRUE;
1374
1375 if (ctxvis->rgbMode != bufvis->rgbMode)
1376 return GL_FALSE;
1377 #if 0
1378 /* disabling this fixes the fgl_glxgears pbuffer demo */
1379 if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
1380 return GL_FALSE;
1381 #endif
1382 if (ctxvis->stereoMode && !bufvis->stereoMode)
1383 return GL_FALSE;
1384 if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
1385 return GL_FALSE;
1386 if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
1387 return GL_FALSE;
1388 if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
1389 return GL_FALSE;
1390 if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
1391 return GL_FALSE;
1392 if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
1393 return GL_FALSE;
1394 if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
1395 return GL_FALSE;
1396 #if 0
1397 /* disabled (see bug 11161) */
1398 if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
1399 return GL_FALSE;
1400 #endif
1401 if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
1402 return GL_FALSE;
1403
1404 return GL_TRUE;
1405 }
1406
1407
1408 /**
1409 * Do one-time initialization for the given framebuffer. Specifically,
1410 * ask the driver for the window's current size and update the framebuffer
1411 * object to match.
1412 * Really, the device driver should totally take care of this.
1413 */
1414 static void
1415 initialize_framebuffer_size(GLcontext *ctx, GLframebuffer *fb)
1416 {
1417 GLuint width, height;
1418 if (ctx->Driver.GetBufferSize) {
1419 ctx->Driver.GetBufferSize(fb, &width, &height);
1420 if (ctx->Driver.ResizeBuffers)
1421 ctx->Driver.ResizeBuffers(ctx, fb, width, height);
1422 fb->Initialized = GL_TRUE;
1423 }
1424 }
1425
1426
1427 /**
1428 * Bind the given context to the given drawBuffer and readBuffer and
1429 * make it the current context for the calling thread.
1430 * We'll render into the drawBuffer and read pixels from the
1431 * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1432 *
1433 * We check that the context's and framebuffer's visuals are compatible
1434 * and return immediately if they're not.
1435 *
1436 * \param newCtx the new GL context. If NULL then there will be no current GL
1437 * context.
1438 * \param drawBuffer the drawing framebuffer
1439 * \param readBuffer the reading framebuffer
1440 */
1441 void
1442 _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
1443 GLframebuffer *readBuffer )
1444 {
1445 GET_CURRENT_CONTEXT(oldCtx);
1446
1447 if (MESA_VERBOSE & VERBOSE_API)
1448 _mesa_debug(newCtx, "_mesa_make_current()\n");
1449
1450 /* Check that the context's and framebuffer's visuals are compatible.
1451 */
1452 if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1453 if (!check_compatible(newCtx, drawBuffer)) {
1454 _mesa_warning(newCtx,
1455 "MakeCurrent: incompatible visuals for context and drawbuffer");
1456 return;
1457 }
1458 }
1459 if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1460 if (!check_compatible(newCtx, readBuffer)) {
1461 _mesa_warning(newCtx,
1462 "MakeCurrent: incompatible visuals for context and readbuffer");
1463 return;
1464 }
1465 }
1466
1467 /* We used to call _glapi_check_multithread() here. Now do it in drivers */
1468 _glapi_set_context((void *) newCtx);
1469 ASSERT(_mesa_get_current_context() == newCtx);
1470
1471 if (oldCtx) {
1472 _mesa_unreference_framebuffer(&oldCtx->WinSysDrawBuffer);
1473 _mesa_unreference_framebuffer(&oldCtx->WinSysReadBuffer);
1474 _mesa_unreference_framebuffer(&oldCtx->DrawBuffer);
1475 _mesa_unreference_framebuffer(&oldCtx->ReadBuffer);
1476 }
1477
1478 if (!newCtx) {
1479 _glapi_set_dispatch(NULL); /* none current */
1480 }
1481 else {
1482 _glapi_set_dispatch(newCtx->CurrentDispatch);
1483
1484 if (drawBuffer && readBuffer) {
1485 /* TODO: check if newCtx and buffer's visual match??? */
1486
1487 ASSERT(drawBuffer->Name == 0);
1488 ASSERT(readBuffer->Name == 0);
1489 _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1490 _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1491
1492 /*
1493 * Only set the context's Draw/ReadBuffer fields if they're NULL
1494 * or not bound to a user-created FBO.
1495 */
1496 if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
1497 _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1498 /* fix up the fb fields - these will end up wrong otherwise
1499 if the DRIdrawable changes, and someone may rely on them.
1500 */
1501 /* What a mess!?! */
1502 int i;
1503 GLenum buffers[MAX_DRAW_BUFFERS];
1504 for(i = 0; i < newCtx->Const.MaxDrawBuffers; i++) {
1505 buffers[i] = newCtx->Color.DrawBuffer[i];
1506 }
1507 _mesa_drawbuffers(newCtx, newCtx->Const.MaxDrawBuffers, buffers, NULL);
1508 }
1509 if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {
1510 _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1511 _mesa_ReadBuffer(newCtx->Pixel.ReadBuffer);
1512 }
1513
1514 newCtx->NewState |= _NEW_BUFFERS;
1515
1516 #if 1
1517 /* We want to get rid of these lines: */
1518
1519 #if _HAVE_FULL_GL
1520 if (!drawBuffer->Initialized) {
1521 initialize_framebuffer_size(newCtx, drawBuffer);
1522 }
1523 if (readBuffer != drawBuffer && !readBuffer->Initialized) {
1524 initialize_framebuffer_size(newCtx, readBuffer);
1525 }
1526
1527 _mesa_resizebuffers(newCtx);
1528 #endif
1529
1530 #else
1531 /* We want the drawBuffer and readBuffer to be initialized by
1532 * the driver.
1533 * This generally means the Width and Height match the actual
1534 * window size and the renderbuffers (both hardware and software
1535 * based) are allocated to match. The later can generally be
1536 * done with a call to _mesa_resize_framebuffer().
1537 *
1538 * It's theoretically possible for a buffer to have zero width
1539 * or height, but for now, assert check that the driver did what's
1540 * expected of it.
1541 */
1542 ASSERT(drawBuffer->Width > 0);
1543 ASSERT(drawBuffer->Height > 0);
1544 #endif
1545
1546 if (newCtx->FirstTimeCurrent) {
1547 /* set initial viewport and scissor size now */
1548 _mesa_set_viewport(newCtx, 0, 0,
1549 drawBuffer->Width, drawBuffer->Height);
1550 _mesa_set_scissor(newCtx, 0, 0,
1551 drawBuffer->Width, drawBuffer->Height );
1552 check_context_limits(newCtx);
1553 }
1554 }
1555
1556 /* We can use this to help debug user's problems. Tell them to set
1557 * the MESA_INFO env variable before running their app. Then the
1558 * first time each context is made current we'll print some useful
1559 * information.
1560 */
1561 if (newCtx->FirstTimeCurrent) {
1562 if (_mesa_getenv("MESA_INFO")) {
1563 _mesa_print_info();
1564 }
1565 newCtx->FirstTimeCurrent = GL_FALSE;
1566 }
1567 }
1568 }
1569
1570
1571 /**
1572 * Make context 'ctx' share the display lists, textures and programs
1573 * that are associated with 'ctxToShare'.
1574 * Any display lists, textures or programs associated with 'ctx' will
1575 * be deleted if nobody else is sharing them.
1576 */
1577 GLboolean
1578 _mesa_share_state(GLcontext *ctx, GLcontext *ctxToShare)
1579 {
1580 if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1581 ctx->Shared->RefCount--;
1582 if (ctx->Shared->RefCount == 0) {
1583 free_shared_state(ctx, ctx->Shared);
1584 }
1585 ctx->Shared = ctxToShare->Shared;
1586 ctx->Shared->RefCount++;
1587 return GL_TRUE;
1588 }
1589 else {
1590 return GL_FALSE;
1591 }
1592 }
1593
1594
1595
1596 /**
1597 * \return pointer to the current GL context for this thread.
1598 *
1599 * Calls _glapi_get_context(). This isn't the fastest way to get the current
1600 * context. If you need speed, see the #GET_CURRENT_CONTEXT macro in
1601 * context.h.
1602 */
1603 GLcontext *
1604 _mesa_get_current_context( void )
1605 {
1606 return (GLcontext *) _glapi_get_context();
1607 }
1608
1609
1610 /**
1611 * Get context's current API dispatch table.
1612 *
1613 * It'll either be the immediate-mode execute dispatcher or the display list
1614 * compile dispatcher.
1615 *
1616 * \param ctx GL context.
1617 *
1618 * \return pointer to dispatch_table.
1619 *
1620 * Simply returns __GLcontextRec::CurrentDispatch.
1621 */
1622 struct _glapi_table *
1623 _mesa_get_dispatch(GLcontext *ctx)
1624 {
1625 return ctx->CurrentDispatch;
1626 }
1627
1628 /*@}*/
1629
1630
1631 /**********************************************************************/
1632 /** \name Miscellaneous functions */
1633 /**********************************************************************/
1634 /*@{*/
1635
1636 /**
1637 * Record an error.
1638 *
1639 * \param ctx GL context.
1640 * \param error error code.
1641 *
1642 * Records the given error code and call the driver's dd_function_table::Error
1643 * function if defined.
1644 *
1645 * \sa
1646 * This is called via _mesa_error().
1647 */
1648 void
1649 _mesa_record_error(GLcontext *ctx, GLenum error)
1650 {
1651 if (!ctx)
1652 return;
1653
1654 if (ctx->ErrorValue == GL_NO_ERROR) {
1655 ctx->ErrorValue = error;
1656 }
1657
1658 /* Call device driver's error handler, if any. This is used on the Mac. */
1659 if (ctx->Driver.Error) {
1660 ctx->Driver.Error(ctx);
1661 }
1662 }
1663
1664
1665 /**
1666 * Execute glFinish().
1667 *
1668 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1669 * dd_function_table::Finish driver callback, if not NULL.
1670 */
1671 void GLAPIENTRY
1672 _mesa_Finish(void)
1673 {
1674 GET_CURRENT_CONTEXT(ctx);
1675 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1676 if (ctx->Driver.Finish) {
1677 ctx->Driver.Finish(ctx);
1678 }
1679 }
1680
1681
1682 /**
1683 * Execute glFlush().
1684 *
1685 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1686 * dd_function_table::Flush driver callback, if not NULL.
1687 */
1688 void GLAPIENTRY
1689 _mesa_Flush(void)
1690 {
1691 GET_CURRENT_CONTEXT(ctx);
1692 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1693 if (ctx->Driver.Flush) {
1694 ctx->Driver.Flush(ctx);
1695 }
1696 }
1697
1698
1699 /*@}*/