projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Rename occlude.[ch] to queryobj.[ch]
[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 "glthread.h"
101 #include "glapioffsets.h"
102 #include "histogram.h"
103 #include "hint.h"
104 #include "hash.h"
105 #include "atifragshader.h"
106 #include "light.h"
107 #include "lines.h"
108 #include "macros.h"
109 #include "matrix.h"
110 #include "pixel.h"
111 #include "points.h"
112 #include "polygon.h"
113 #if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
114 #include "program.h"
115 #endif
116 #include "queryobj.h"
117 #include "rastpos.h"
118 #include "simple_list.h"
119 #include "state.h"
120 #include "stencil.h"
121 #include "texcompress.h"
122 #include "teximage.h"
123 #include "texobj.h"
124 #include "texstate.h"
125 #include "mtypes.h"
126 #include "varray.h"
127 #include "version.h"
128 #include "vtxfmt.h"
129 #if _HAVE_FULL_GL
130 #include "math/m_translate.h"
131 #include "math/m_matrix.h"
132 #include "math/m_xform.h"
133 #include "math/mathmod.h"
134 #endif
135 #include "shader_api.h"
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 /* Effectively bind the default textures to all texture units */
471 ss->Default1D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
472 ss->Default2D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
473 ss->Default3D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
474 ss->DefaultCubeMap->RefCount += MAX_TEXTURE_IMAGE_UNITS;
475 ss->DefaultRect->RefCount += MAX_TEXTURE_IMAGE_UNITS;
476
477 _glthread_INIT_MUTEX(ss->TexMutex);
478 ss->TextureStateStamp = 0;
479
480
481 #if FEATURE_EXT_framebuffer_object
482 ss->FrameBuffers = _mesa_NewHashTable();
483 if (!ss->FrameBuffers)
484 goto cleanup;
485 ss->RenderBuffers = _mesa_NewHashTable();
486 if (!ss->RenderBuffers)
487 goto cleanup;
488 #endif
489
490
491 return GL_TRUE;
492
493 cleanup:
494 /* Ran out of memory at some point. Free everything and return NULL */
495 if (ss->DisplayList)
496 _mesa_DeleteHashTable(ss->DisplayList);
497 if (ss->TexObjects)
498 _mesa_DeleteHashTable(ss->TexObjects);
499 #if FEATURE_NV_vertex_program
500 if (ss->Programs)
501 _mesa_DeleteHashTable(ss->Programs);
502 #endif
503 #if FEATURE_ARB_vertex_program
504 if (ss->DefaultVertexProgram)
505 ctx->Driver.DeleteProgram(ctx, ss->DefaultVertexProgram);
506 #endif
507 #if FEATURE_ARB_fragment_program
508 if (ss->DefaultFragmentProgram)
509 ctx->Driver.DeleteProgram(ctx, ss->DefaultFragmentProgram);
510 #endif
511 #if FEATURE_ATI_fragment_shader
512 if (ss->DefaultFragmentShader)
513 _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
514 #endif
515 #if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
516 if (ss->BufferObjects)
517 _mesa_DeleteHashTable(ss->BufferObjects);
518 #endif
519
520 if (ss->ArrayObjects)
521 _mesa_DeleteHashTable (ss->ArrayObjects);
522
523 #if FEATURE_ARB_shader_objects
524 if (ss->ShaderObjects)
525 _mesa_DeleteHashTable (ss->ShaderObjects);
526 #endif
527
528 #if FEATURE_EXT_framebuffer_object
529 if (ss->FrameBuffers)
530 _mesa_DeleteHashTable(ss->FrameBuffers);
531 if (ss->RenderBuffers)
532 _mesa_DeleteHashTable(ss->RenderBuffers);
533 #endif
534
535 if (ss->Default1D)
536 (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D);
537 if (ss->Default2D)
538 (*ctx->Driver.DeleteTexture)(ctx, ss->Default2D);
539 if (ss->Default3D)
540 (*ctx->Driver.DeleteTexture)(ctx, ss->Default3D);
541 if (ss->DefaultCubeMap)
542 (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap);
543 if (ss->DefaultRect)
544 (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect);
545 if (ss)
546 _mesa_free(ss);
547 return GL_FALSE;
548 }
549
550
551 /**
552 * Callback for deleting a display list. Called by _mesa_HashDeleteAll().
553 */
554 static void
555 delete_displaylist_cb(GLuint id, void *data, void *userData)
556 {
557 struct mesa_display_list *list = (struct mesa_display_list *) data;
558 GLcontext *ctx = (GLcontext *) userData;
559 _mesa_delete_list(ctx, list);
560 }
561
562 /**
563 * Callback for deleting a texture object. Called by _mesa_HashDeleteAll().
564 */
565 static void
566 delete_texture_cb(GLuint id, void *data, void *userData)
567 {
568 struct gl_texture_object *texObj = (struct gl_texture_object *) data;
569 GLcontext *ctx = (GLcontext *) userData;
570 ctx->Driver.DeleteTexture(ctx, texObj);
571 }
572
573 /**
574 * Callback for deleting a program object. Called by _mesa_HashDeleteAll().
575 */
576 static void
577 delete_program_cb(GLuint id, void *data, void *userData)
578 {
579 struct gl_program *prog = (struct gl_program *) data;
580 GLcontext *ctx = (GLcontext *) userData;
581 ctx->Driver.DeleteProgram(ctx, prog);
582 }
583
584 /**
585 * Callback for deleting an ATI fragment shader object.
586 * Called by _mesa_HashDeleteAll().
587 */
588 static void
589 delete_fragshader_cb(GLuint id, void *data, void *userData)
590 {
591 struct ati_fragment_shader *shader = (struct ati_fragment_shader *) data;
592 GLcontext *ctx = (GLcontext *) userData;
593 _mesa_delete_ati_fragment_shader(ctx, shader);
594 }
595
596 /**
597 * Callback for deleting a buffer object. Called by _mesa_HashDeleteAll().
598 */
599 static void
600 delete_bufferobj_cb(GLuint id, void *data, void *userData)
601 {
602 struct gl_buffer_object *bufObj = (struct gl_buffer_object *) data;
603 GLcontext *ctx = (GLcontext *) userData;
604 ctx->Driver.DeleteBuffer(ctx, bufObj);
605 }
606
607 /**
608 * Callback for deleting an array object. Called by _mesa_HashDeleteAll().
609 */
610 static void
611 delete_arrayobj_cb(GLuint id, void *data, void *userData)
612 {
613 struct gl_array_object *arrayObj = (struct gl_array_object *) data;
614 GLcontext *ctx = (GLcontext *) userData;
615 _mesa_delete_array_object(ctx, arrayObj);
616 }
617
618 /**
619 * Callback for deleting shader and shader programs objects.
620 * Called by _mesa_HashDeleteAll().
621 */
622 static void
623 delete_shader_cb(GLuint id, void *data, void *userData)
624 {
625 GLcontext *ctx = (GLcontext *) userData;
626 struct gl_shader *sh = (struct gl_shader *) data;
627 if (sh->Type == GL_FRAGMENT_SHADER || sh->Type == GL_VERTEX_SHADER) {
628 _mesa_free_shader(ctx, sh);
629 }
630 else {
631 struct gl_shader_program *shProg = (struct gl_shader_program *) data;
632 ASSERT(shProg->Type == GL_SHADER_PROGRAM_MESA);
633 _mesa_free_shader_program(ctx, shProg);
634 }
635 }
636
637
638 /**
639 * Deallocate a shared state object and all children structures.
640 *
641 * \param ctx GL context.
642 * \param ss shared state pointer.
643 *
644 * Frees the display lists, the texture objects (calling the driver texture
645 * deletion callback to free its private data) and the vertex programs, as well
646 * as their hash tables.
647 *
648 * \sa alloc_shared_state().
649 */
650 static void
651 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
652 {
653 /*
654 * Free display lists
655 */
656 _mesa_HashDeleteAll(ss->DisplayList, delete_displaylist_cb, ctx);
657 _mesa_DeleteHashTable(ss->DisplayList);
658
659 /*
660 * Free texture objects
661 */
662 ASSERT(ctx->Driver.DeleteTexture);
663 /* the default textures */
664 ctx->Driver.DeleteTexture(ctx, ss->Default1D);
665 ctx->Driver.DeleteTexture(ctx, ss->Default2D);
666 ctx->Driver.DeleteTexture(ctx, ss->Default3D);
667 ctx->Driver.DeleteTexture(ctx, ss->DefaultCubeMap);
668 ctx->Driver.DeleteTexture(ctx, ss->DefaultRect);
669 /* all other textures */
670 _mesa_HashDeleteAll(ss->TexObjects, delete_texture_cb, ctx);
671 _mesa_DeleteHashTable(ss->TexObjects);
672
673 #if defined(FEATURE_NV_vertex_program) || defined(FEATURE_NV_fragment_program)
674 _mesa_HashDeleteAll(ss->Programs, delete_program_cb, ctx);
675 _mesa_DeleteHashTable(ss->Programs);
676 #endif
677 #if FEATURE_ARB_vertex_program
678 _mesa_delete_program(ctx, ss->DefaultVertexProgram);
679 #endif
680 #if FEATURE_ARB_fragment_program
681 _mesa_delete_program(ctx, ss->DefaultFragmentProgram);
682 #endif
683
684 #if FEATURE_ATI_fragment_shader
685 _mesa_HashDeleteAll(ss->ATIShaders, delete_fragshader_cb, ctx);
686 _mesa_DeleteHashTable(ss->ATIShaders);
687 _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
688 #endif
689
690 #if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
691 _mesa_HashDeleteAll(ss->BufferObjects, delete_bufferobj_cb, ctx);
692 _mesa_DeleteHashTable(ss->BufferObjects);
693 #endif
694
695 _mesa_HashDeleteAll(ss->ArrayObjects, delete_arrayobj_cb, ctx);
696 _mesa_DeleteHashTable(ss->ArrayObjects);
697
698 #if FEATURE_ARB_shader_objects
699 _mesa_HashDeleteAll(ss->ShaderObjects, delete_shader_cb, ctx);
700 _mesa_DeleteHashTable(ss->ShaderObjects);
701 #endif
702
703 #if FEATURE_EXT_framebuffer_object
704 _mesa_DeleteHashTable(ss->FrameBuffers);
705 _mesa_DeleteHashTable(ss->RenderBuffers);
706 #endif
707
708 _glthread_DESTROY_MUTEX(ss->Mutex);
709
710 _mesa_free(ss);
711 }
712
713
714 /**
715 * Initialize fields of gl_current_attrib (aka ctx->Current.*)
716 */
717 static void
718 _mesa_init_current(GLcontext *ctx)
719 {
720 GLuint i;
721
722 /* Init all to (0,0,0,1) */
723 for (i = 0; i < VERT_ATTRIB_MAX; i++) {
724 ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
725 }
726
727 /* redo special cases: */
728 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 1.0 );
729 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
730 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
731 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
732 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
733 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
734 }
735
736
737 /**
738 * Init vertex/fragment program native limits from logical limits.
739 */
740 static void
741 init_natives(struct gl_program_constants *prog)
742 {
743 prog->MaxNativeInstructions = prog->MaxInstructions;
744 prog->MaxNativeAluInstructions = prog->MaxAluInstructions;
745 prog->MaxNativeTexInstructions = prog->MaxTexInstructions;
746 prog->MaxNativeTexIndirections = prog->MaxTexIndirections;
747 prog->MaxNativeAttribs = prog->MaxAttribs;
748 prog->MaxNativeTemps = prog->MaxTemps;
749 prog->MaxNativeAddressRegs = prog->MaxAddressRegs;
750 prog->MaxNativeParameters = prog->MaxParameters;
751 }
752
753
754 /**
755 * Initialize fields of gl_constants (aka ctx->Const.*).
756 * Use defaults from config.h. The device drivers will often override
757 * some of these values (such as number of texture units).
758 */
759 static void
760 _mesa_init_constants(GLcontext *ctx)
761 {
762 assert(ctx);
763
764 assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
765 assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
766
767 assert(MAX_TEXTURE_UNITS >= MAX_TEXTURE_COORD_UNITS);
768 assert(MAX_TEXTURE_UNITS >= MAX_TEXTURE_IMAGE_UNITS);
769
770 /* Constants, may be overriden (usually only reduced) by device drivers */
771 ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
772 ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
773 ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
774 ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
775 ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
776 ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
777 ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,
778 ctx->Const.MaxTextureImageUnits);
779 ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
780 ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
781 ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
782 ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
783 ctx->Const.MinPointSize = MIN_POINT_SIZE;
784 ctx->Const.MaxPointSize = MAX_POINT_SIZE;
785 ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
786 ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
787 ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
788 ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
789 ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
790 ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
791 ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
792 ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
793 ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
794 ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
795 ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
796 ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
797 ctx->Const.MaxLights = MAX_LIGHTS;
798 ctx->Const.MaxShininess = 128.0;
799 ctx->Const.MaxSpotExponent = 128.0;
800 ctx->Const.MaxViewportWidth = MAX_WIDTH;
801 ctx->Const.MaxViewportHeight = MAX_HEIGHT;
802 #if FEATURE_ARB_vertex_program
803 ctx->Const.VertexProgram.MaxInstructions = MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS;
804 ctx->Const.VertexProgram.MaxAluInstructions = 0;
805 ctx->Const.VertexProgram.MaxTexInstructions = 0;
806 ctx->Const.VertexProgram.MaxTexIndirections = 0;
807 ctx->Const.VertexProgram.MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
808 ctx->Const.VertexProgram.MaxTemps = MAX_PROGRAM_TEMPS;
809 ctx->Const.VertexProgram.MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
810 ctx->Const.VertexProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
811 ctx->Const.VertexProgram.MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
812 ctx->Const.VertexProgram.MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
813 ctx->Const.VertexProgram.MaxUniformComponents = 4 * MAX_UNIFORMS;
814 init_natives(&ctx->Const.VertexProgram);
815 #endif
816
817 #if FEATURE_ARB_fragment_program
818 ctx->Const.FragmentProgram.MaxInstructions = MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS;
819 ctx->Const.FragmentProgram.MaxAluInstructions = MAX_FRAGMENT_PROGRAM_ALU_INSTRUCTIONS;
820 ctx->Const.FragmentProgram.MaxTexInstructions = MAX_FRAGMENT_PROGRAM_TEX_INSTRUCTIONS;
821 ctx->Const.FragmentProgram.MaxTexIndirections = MAX_FRAGMENT_PROGRAM_TEX_INDIRECTIONS;
822 ctx->Const.FragmentProgram.MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
823 ctx->Const.FragmentProgram.MaxTemps = MAX_PROGRAM_TEMPS;
824 ctx->Const.FragmentProgram.MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
825 ctx->Const.FragmentProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
826 ctx->Const.FragmentProgram.MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
827 ctx->Const.FragmentProgram.MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
828 ctx->Const.FragmentProgram.MaxUniformComponents = 4 * MAX_UNIFORMS;
829 init_natives(&ctx->Const.FragmentProgram);
830 #endif
831 ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
832 ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
833
834 /* CheckArrayBounds is overriden by drivers/x11 for X server */
835 ctx->Const.CheckArrayBounds = GL_FALSE;
836
837 /* GL_ARB_draw_buffers */
838 ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
839
840 /* GL_OES_read_format */
841 ctx->Const.ColorReadFormat = GL_RGBA;
842 ctx->Const.ColorReadType = GL_UNSIGNED_BYTE;
843
844 #if FEATURE_EXT_framebuffer_object
845 ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
846 ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
847 #endif
848
849 #if FEATURE_ARB_vertex_shader
850 ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
851 ctx->Const.MaxVarying = MAX_VARYING;
852 #endif
853
854 /* sanity checks */
855 ASSERT(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,
856 ctx->Const.MaxTextureCoordUnits));
857 ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
858 ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
859
860 ASSERT(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
861 ASSERT(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
862 ASSERT(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);
863 ASSERT(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);
864 }
865
866
867 /**
868 * Do some sanity checks on the limits/constants for the given context.
869 * Only called the first time a context is bound.
870 */
871 static void
872 check_context_limits(GLcontext *ctx)
873 {
874 /* Many context limits/constants are limited by the size of
875 * internal arrays.
876 */
877 assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
878 assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
879 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
880 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
881
882 assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);
883 assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);
884
885 /* make sure largest texture image is <= MAX_WIDTH in size */
886 assert((1 << (ctx->Const.MaxTextureLevels -1 )) <= MAX_WIDTH);
887 assert((1 << (ctx->Const.MaxCubeTextureLevels -1 )) <= MAX_WIDTH);
888 assert((1 << (ctx->Const.Max3DTextureLevels -1 )) <= MAX_WIDTH);
889
890 assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
891
892 /* XXX probably add more tests */
893 }
894
895
896 /**
897 * Initialize the attribute groups in a GL context.
898 *
899 * \param ctx GL context.
900 *
901 * Initializes all the attributes, calling the respective <tt>init*</tt>
902 * functions for the more complex data structures.
903 */
904 static GLboolean
905 init_attrib_groups(GLcontext *ctx)
906 {
907 assert(ctx);
908
909 /* Constants */
910 _mesa_init_constants( ctx );
911
912 /* Extensions */
913 _mesa_init_extensions( ctx );
914
915 /* Attribute Groups */
916 _mesa_init_accum( ctx );
917 _mesa_init_attrib( ctx );
918 _mesa_init_buffer_objects( ctx );
919 _mesa_init_color( ctx );
920 _mesa_init_colortables( ctx );
921 _mesa_init_current( ctx );
922 _mesa_init_depth( ctx );
923 _mesa_init_debug( ctx );
924 _mesa_init_display_list( ctx );
925 _mesa_init_eval( ctx );
926 _mesa_init_feedback( ctx );
927 _mesa_init_fog( ctx );
928 _mesa_init_histogram( ctx );
929 _mesa_init_hint( ctx );
930 _mesa_init_line( ctx );
931 _mesa_init_lighting( ctx );
932 _mesa_init_matrix( ctx );
933 _mesa_init_multisample( ctx );
934 _mesa_init_pixel( ctx );
935 _mesa_init_point( ctx );
936 _mesa_init_polygon( ctx );
937 _mesa_init_program( ctx );
938 _mesa_init_query( ctx );
939 _mesa_init_rastpos( ctx );
940 _mesa_init_scissor( ctx );
941 _mesa_init_shader_state( ctx );
942 _mesa_init_stencil( ctx );
943 _mesa_init_transform( ctx );
944 _mesa_init_varray( ctx );
945 _mesa_init_viewport( ctx );
946
947 if (!_mesa_init_texture( ctx ))
948 return GL_FALSE;
949
950 _mesa_init_texture_s3tc( ctx );
951 _mesa_init_texture_fxt1( ctx );
952
953 /* Miscellaneous */
954 ctx->NewState = _NEW_ALL;
955 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
956 ctx->_Facing = 0;
957
958 return GL_TRUE;
959 }
960
961
962 /**
963 * This is the default function we plug into all dispatch table slots
964 * This helps prevents a segfault when someone calls a GL function without
965 * first checking if the extension's supported.
966 */
967 static int
968 generic_nop(void)
969 {
970 _mesa_problem(NULL, "User called no-op dispatch function (an unsupported extension function?)");
971 return 0;
972 }
973
974
975 /**
976 * Allocate and initialize a new dispatch table.
977 */
978 static struct _glapi_table *
979 alloc_dispatch_table(void)
980 {
981 /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
982 * In practice, this'll be the same for stand-alone Mesa. But for DRI
983 * Mesa we do this to accomodate different versions of libGL and various
984 * DRI drivers.
985 */
986 GLint numEntries = MAX2(_glapi_get_dispatch_table_size(),
987 sizeof(struct _glapi_table) / sizeof(_glapi_proc));
988 struct _glapi_table *table =
989 (struct _glapi_table *) _mesa_malloc(numEntries * sizeof(_glapi_proc));
990 if (table) {
991 _glapi_proc *entry = (_glapi_proc *) table;
992 GLint i;
993 for (i = 0; i < numEntries; i++) {
994 entry[i] = (_glapi_proc) generic_nop;
995 }
996 }
997 return table;
998 }
999
1000
1001 /**
1002 * Initialize a GLcontext struct (rendering context).
1003 *
1004 * This includes allocating all the other structs and arrays which hang off of
1005 * the context by pointers.
1006 * Note that the driver needs to pass in its dd_function_table here since
1007 * we need to at least call driverFunctions->NewTextureObject to create the
1008 * default texture objects.
1009 *
1010 * Called by _mesa_create_context().
1011 *
1012 * Performs the imports and exports callback tables initialization, and
1013 * miscellaneous one-time initializations. If no shared context is supplied one
1014 * is allocated, and increase its reference count. Setups the GL API dispatch
1015 * tables. Initialize the TNL module. Sets the maximum Z buffer depth.
1016 * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1017 * for debug flags.
1018 *
1019 * \param ctx the context to initialize
1020 * \param visual describes the visual attributes for this context
1021 * \param share_list points to context to share textures, display lists,
1022 * etc with, or NULL
1023 * \param driverFunctions table of device driver functions for this context
1024 * to use
1025 * \param driverContext pointer to driver-specific context data
1026 */
1027 GLboolean
1028 _mesa_initialize_context(GLcontext *ctx,
1029 const GLvisual *visual,
1030 GLcontext *share_list,
1031 const struct dd_function_table *driverFunctions,
1032 void *driverContext)
1033 {
1034 ASSERT(driverContext);
1035 assert(driverFunctions->NewTextureObject);
1036 assert(driverFunctions->FreeTexImageData);
1037
1038 /* misc one-time initializations */
1039 one_time_init(ctx);
1040
1041 ctx->Visual = *visual;
1042 ctx->DrawBuffer = NULL;
1043 ctx->ReadBuffer = NULL;
1044 ctx->WinSysDrawBuffer = NULL;
1045 ctx->WinSysReadBuffer = NULL;
1046
1047 /* Plug in driver functions and context pointer here.
1048 * This is important because when we call alloc_shared_state() below
1049 * we'll call ctx->Driver.NewTextureObject() to create the default
1050 * textures.
1051 */
1052 ctx->Driver = *driverFunctions;
1053 ctx->DriverCtx = driverContext;
1054
1055 if (share_list) {
1056 /* share state with another context */
1057 ctx->Shared = share_list->Shared;
1058 }
1059 else {
1060 /* allocate new, unshared state */
1061 if (!alloc_shared_state( ctx )) {
1062 return GL_FALSE;
1063 }
1064 }
1065 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1066 ctx->Shared->RefCount++;
1067 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1068
1069 if (!init_attrib_groups( ctx )) {
1070 free_shared_state(ctx, ctx->Shared);
1071 return GL_FALSE;
1072 }
1073
1074 /* setup the API dispatch tables */
1075 ctx->Exec = alloc_dispatch_table();
1076 ctx->Save = alloc_dispatch_table();
1077 if (!ctx->Exec || !ctx->Save) {
1078 free_shared_state(ctx, ctx->Shared);
1079 if (ctx->Exec)
1080 _mesa_free(ctx->Exec);
1081 }
1082 _mesa_init_exec_table(ctx->Exec);
1083 ctx->CurrentDispatch = ctx->Exec;
1084 #if _HAVE_FULL_GL
1085 _mesa_init_dlist_table(ctx->Save);
1086 _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
1087 /* Neutral tnl module stuff */
1088 _mesa_init_exec_vtxfmt( ctx );
1089 ctx->TnlModule.Current = NULL;
1090 ctx->TnlModule.SwapCount = 0;
1091 #endif
1092
1093 ctx->FragmentProgram._MaintainTexEnvProgram
1094 = (_mesa_getenv("MESA_TEX_PROG") != NULL);
1095 ctx->FragmentProgram._UseTexEnvProgram = ctx->FragmentProgram._MaintainTexEnvProgram;
1096
1097 ctx->VertexProgram._MaintainTnlProgram
1098 = (_mesa_getenv("MESA_TNL_PROG") != NULL);
1099 if (ctx->VertexProgram._MaintainTnlProgram) {
1100 /* this is required... */
1101 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1102 }
1103
1104 ctx->FirstTimeCurrent = GL_TRUE;
1105
1106 return GL_TRUE;
1107 }
1108
1109
1110 /**
1111 * Allocate and initialize a GLcontext structure.
1112 * Note that the driver needs to pass in its dd_function_table here since
1113 * we need to at least call driverFunctions->NewTextureObject to initialize
1114 * the rendering context.
1115 *
1116 * \param visual a GLvisual pointer (we copy the struct contents)
1117 * \param share_list another context to share display lists with or NULL
1118 * \param driverFunctions points to the dd_function_table into which the
1119 * driver has plugged in all its special functions.
1120 * \param driverCtx points to the device driver's private context state
1121 *
1122 * \return pointer to a new __GLcontextRec or NULL if error.
1123 */
1124 GLcontext *
1125 _mesa_create_context(const GLvisual *visual,
1126 GLcontext *share_list,
1127 const struct dd_function_table *driverFunctions,
1128 void *driverContext)
1129 {
1130 GLcontext *ctx;
1131
1132 ASSERT(visual);
1133 ASSERT(driverContext);
1134
1135 ctx = (GLcontext *) _mesa_calloc(sizeof(GLcontext));
1136 if (!ctx)
1137 return NULL;
1138
1139 if (_mesa_initialize_context(ctx, visual, share_list,
1140 driverFunctions, driverContext)) {
1141 return ctx;
1142 }
1143 else {
1144 _mesa_free(ctx);
1145 return NULL;
1146 }
1147 }
1148
1149
1150 /**
1151 * Free the data associated with the given context.
1152 *
1153 * But doesn't free the GLcontext struct itself.
1154 *
1155 * \sa _mesa_initialize_context() and init_attrib_groups().
1156 */
1157 void
1158 _mesa_free_context_data( GLcontext *ctx )
1159 {
1160 /* if we're destroying the current context, unbind it first */
1161 if (ctx == _mesa_get_current_context()) {
1162 _mesa_make_current(NULL, NULL, NULL);
1163 }
1164 else {
1165 /* unreference WinSysDraw/Read buffers */
1166 _mesa_unreference_framebuffer(&ctx->WinSysDrawBuffer);
1167 _mesa_unreference_framebuffer(&ctx->WinSysReadBuffer);
1168 _mesa_unreference_framebuffer(&ctx->DrawBuffer);
1169 _mesa_unreference_framebuffer(&ctx->ReadBuffer);
1170 }
1171
1172 _mesa_free_lighting_data( ctx );
1173 _mesa_free_eval_data( ctx );
1174 _mesa_free_texture_data( ctx );
1175 _mesa_free_matrix_data( ctx );
1176 _mesa_free_viewport_data( ctx );
1177 _mesa_free_colortables_data( ctx );
1178 _mesa_free_program_data(ctx);
1179 _mesa_free_shader_state(ctx);
1180 _mesa_free_query_data(ctx);
1181
1182 #if FEATURE_ARB_vertex_buffer_object
1183 _mesa_delete_buffer_object(ctx, ctx->Array.NullBufferObj);
1184 #endif
1185 _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);
1186
1187 /* free dispatch tables */
1188 _mesa_free(ctx->Exec);
1189 _mesa_free(ctx->Save);
1190
1191 /* Shared context state (display lists, textures, etc) */
1192 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1193 ctx->Shared->RefCount--;
1194 assert(ctx->Shared->RefCount >= 0);
1195 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1196 if (ctx->Shared->RefCount == 0) {
1197 /* free shared state */
1198 free_shared_state( ctx, ctx->Shared );
1199 }
1200
1201 if (ctx->Extensions.String)
1202 _mesa_free((void *) ctx->Extensions.String);
1203 }
1204
1205
1206 /**
1207 * Destroy a GLcontext structure.
1208 *
1209 * \param ctx GL context.
1210 *
1211 * Calls _mesa_free_context_data() and frees the GLcontext structure itself.
1212 */
1213 void
1214 _mesa_destroy_context( GLcontext *ctx )
1215 {
1216 if (ctx) {
1217 _mesa_free_context_data(ctx);
1218 _mesa_free( (void *) ctx );
1219 }
1220 }
1221
1222
1223 #if _HAVE_FULL_GL
1224 /**
1225 * Copy attribute groups from one context to another.
1226 *
1227 * \param src source context
1228 * \param dst destination context
1229 * \param mask bitwise OR of GL_*_BIT flags
1230 *
1231 * According to the bits specified in \p mask, copies the corresponding
1232 * attributes from \p src into \p dst. For many of the attributes a simple \c
1233 * memcpy is not enough due to the existence of internal pointers in their data
1234 * structures.
1235 */
1236 void
1237 _mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1238 {
1239 if (mask & GL_ACCUM_BUFFER_BIT) {
1240 /* OK to memcpy */
1241 dst->Accum = src->Accum;
1242 }
1243 if (mask & GL_COLOR_BUFFER_BIT) {
1244 /* OK to memcpy */
1245 dst->Color = src->Color;
1246 }
1247 if (mask & GL_CURRENT_BIT) {
1248 /* OK to memcpy */
1249 dst->Current = src->Current;
1250 }
1251 if (mask & GL_DEPTH_BUFFER_BIT) {
1252 /* OK to memcpy */
1253 dst->Depth = src->Depth;
1254 }
1255 if (mask & GL_ENABLE_BIT) {
1256 /* no op */
1257 }
1258 if (mask & GL_EVAL_BIT) {
1259 /* OK to memcpy */
1260 dst->Eval = src->Eval;
1261 }
1262 if (mask & GL_FOG_BIT) {
1263 /* OK to memcpy */
1264 dst->Fog = src->Fog;
1265 }
1266 if (mask & GL_HINT_BIT) {
1267 /* OK to memcpy */
1268 dst->Hint = src->Hint;
1269 }
1270 if (mask & GL_LIGHTING_BIT) {
1271 GLuint i;
1272 /* begin with memcpy */
1273 dst->Light = src->Light;
1274 /* fixup linked lists to prevent pointer insanity */
1275 make_empty_list( &(dst->Light.EnabledList) );
1276 for (i = 0; i < MAX_LIGHTS; i++) {
1277 if (dst->Light.Light[i].Enabled) {
1278 insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
1279 }
1280 }
1281 }
1282 if (mask & GL_LINE_BIT) {
1283 /* OK to memcpy */
1284 dst->Line = src->Line;
1285 }
1286 if (mask & GL_LIST_BIT) {
1287 /* OK to memcpy */
1288 dst->List = src->List;
1289 }
1290 if (mask & GL_PIXEL_MODE_BIT) {
1291 /* OK to memcpy */
1292 dst->Pixel = src->Pixel;
1293 }
1294 if (mask & GL_POINT_BIT) {
1295 /* OK to memcpy */
1296 dst->Point = src->Point;
1297 }
1298 if (mask & GL_POLYGON_BIT) {
1299 /* OK to memcpy */
1300 dst->Polygon = src->Polygon;
1301 }
1302 if (mask & GL_POLYGON_STIPPLE_BIT) {
1303 /* Use loop instead of MEMCPY due to problem with Portland Group's
1304 * C compiler. Reported by John Stone.
1305 */
1306 GLuint i;
1307 for (i = 0; i < 32; i++) {
1308 dst->PolygonStipple[i] = src->PolygonStipple[i];
1309 }
1310 }
1311 if (mask & GL_SCISSOR_BIT) {
1312 /* OK to memcpy */
1313 dst->Scissor = src->Scissor;
1314 }
1315 if (mask & GL_STENCIL_BUFFER_BIT) {
1316 /* OK to memcpy */
1317 dst->Stencil = src->Stencil;
1318 }
1319 if (mask & GL_TEXTURE_BIT) {
1320 /* Cannot memcpy because of pointers */
1321 _mesa_copy_texture_state(src, dst);
1322 }
1323 if (mask & GL_TRANSFORM_BIT) {
1324 /* OK to memcpy */
1325 dst->Transform = src->Transform;
1326 }
1327 if (mask & GL_VIEWPORT_BIT) {
1328 /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
1329 dst->Viewport.X = src->Viewport.X;
1330 dst->Viewport.Y = src->Viewport.Y;
1331 dst->Viewport.Width = src->Viewport.Width;
1332 dst->Viewport.Height = src->Viewport.Height;
1333 dst->Viewport.Near = src->Viewport.Near;
1334 dst->Viewport.Far = src->Viewport.Far;
1335 _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
1336 }
1337
1338 /* XXX FIXME: Call callbacks?
1339 */
1340 dst->NewState = _NEW_ALL;
1341 }
1342 #endif
1343
1344
1345 /**
1346 * Check if the given context can render into the given framebuffer
1347 * by checking visual attributes.
1348 *
1349 * XXX this may go away someday because we're moving toward more freedom
1350 * in binding contexts to drawables with different visual attributes.
1351 * The GL_EXT_f_b_o extension is prompting some of that.
1352 *
1353 * \return GL_TRUE if compatible, GL_FALSE otherwise.
1354 */
1355 static GLboolean
1356 check_compatible(const GLcontext *ctx, const GLframebuffer *buffer)
1357 {
1358 const GLvisual *ctxvis = &ctx->Visual;
1359 const GLvisual *bufvis = &buffer->Visual;
1360
1361 if (ctxvis == bufvis)
1362 return GL_TRUE;
1363
1364 if (ctxvis->rgbMode != bufvis->rgbMode)
1365 return GL_FALSE;
1366 #if 0
1367 /* disabling this fixes the fgl_glxgears pbuffer demo */
1368 if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
1369 return GL_FALSE;
1370 #endif
1371 if (ctxvis->stereoMode && !bufvis->stereoMode)
1372 return GL_FALSE;
1373 if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
1374 return GL_FALSE;
1375 if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
1376 return GL_FALSE;
1377 if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
1378 return GL_FALSE;
1379 if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
1380 return GL_FALSE;
1381 if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
1382 return GL_FALSE;
1383 if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
1384 return GL_FALSE;
1385 if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
1386 return GL_FALSE;
1387 if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
1388 return GL_FALSE;
1389
1390 return GL_TRUE;
1391 }
1392
1393
1394 /**
1395 * Do one-time initialization for the given framebuffer. Specifically,
1396 * ask the driver for the window's current size and update the framebuffer
1397 * object to match.
1398 * Really, the device driver should totally take care of this.
1399 */
1400 static void
1401 initialize_framebuffer_size(GLcontext *ctx, GLframebuffer *fb)
1402 {
1403 GLuint width, height;
1404 if (ctx->Driver.GetBufferSize) {
1405 ctx->Driver.GetBufferSize(fb, &width, &height);
1406 if (ctx->Driver.ResizeBuffers)
1407 ctx->Driver.ResizeBuffers(ctx, fb, width, height);
1408 fb->Initialized = GL_TRUE;
1409 }
1410 }
1411
1412
1413 /**
1414 * Bind the given context to the given drawBuffer and readBuffer and
1415 * make it the current context for the calling thread.
1416 * We'll render into the drawBuffer and read pixels from the
1417 * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1418 *
1419 * We check that the context's and framebuffer's visuals are compatible
1420 * and return immediately if they're not.
1421 *
1422 * \param newCtx the new GL context. If NULL then there will be no current GL
1423 * context.
1424 * \param drawBuffer the drawing framebuffer
1425 * \param readBuffer the reading framebuffer
1426 */
1427 void
1428 _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
1429 GLframebuffer *readBuffer )
1430 {
1431 GET_CURRENT_CONTEXT(oldCtx);
1432
1433 if (MESA_VERBOSE & VERBOSE_API)
1434 _mesa_debug(newCtx, "_mesa_make_current()\n");
1435
1436 /* Check that the context's and framebuffer's visuals are compatible.
1437 */
1438 if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1439 if (!check_compatible(newCtx, drawBuffer)) {
1440 _mesa_warning(newCtx,
1441 "MakeCurrent: incompatible visuals for context and drawbuffer");
1442 return;
1443 }
1444 }
1445 if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1446 if (!check_compatible(newCtx, readBuffer)) {
1447 _mesa_warning(newCtx,
1448 "MakeCurrent: incompatible visuals for context and readbuffer");
1449 return;
1450 }
1451 }
1452
1453 /* We used to call _glapi_check_multithread() here. Now do it in drivers */
1454 _glapi_set_context((void *) newCtx);
1455 ASSERT(_mesa_get_current_context() == newCtx);
1456
1457 if (oldCtx) {
1458 _mesa_unreference_framebuffer(&oldCtx->WinSysDrawBuffer);
1459 _mesa_unreference_framebuffer(&oldCtx->WinSysReadBuffer);
1460 _mesa_unreference_framebuffer(&oldCtx->DrawBuffer);
1461 _mesa_unreference_framebuffer(&oldCtx->ReadBuffer);
1462 }
1463
1464 if (!newCtx) {
1465 _glapi_set_dispatch(NULL); /* none current */
1466 }
1467 else {
1468 _glapi_set_dispatch(newCtx->CurrentDispatch);
1469
1470 if (drawBuffer && readBuffer) {
1471 /* TODO: check if newCtx and buffer's visual match??? */
1472
1473 ASSERT(drawBuffer->Name == 0);
1474 ASSERT(readBuffer->Name == 0);
1475 _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1476 _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1477
1478 /*
1479 * Only set the context's Draw/ReadBuffer fields if they're NULL
1480 * or not bound to a user-created FBO.
1481 */
1482 if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
1483 _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1484 }
1485 if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {
1486 _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1487 }
1488
1489 newCtx->NewState |= _NEW_BUFFERS;
1490
1491 #if 1
1492 /* We want to get rid of these lines: */
1493
1494 #if _HAVE_FULL_GL
1495 if (!drawBuffer->Initialized) {
1496 initialize_framebuffer_size(newCtx, drawBuffer);
1497 }
1498 if (readBuffer != drawBuffer && !readBuffer->Initialized) {
1499 initialize_framebuffer_size(newCtx, readBuffer);
1500 }
1501
1502 _mesa_resizebuffers(newCtx);
1503 #endif
1504
1505 #else
1506 /* We want the drawBuffer and readBuffer to be initialized by
1507 * the driver.
1508 * This generally means the Width and Height match the actual
1509 * window size and the renderbuffers (both hardware and software
1510 * based) are allocated to match. The later can generally be
1511 * done with a call to _mesa_resize_framebuffer().
1512 *
1513 * It's theoretically possible for a buffer to have zero width
1514 * or height, but for now, assert check that the driver did what's
1515 * expected of it.
1516 */
1517 ASSERT(drawBuffer->Width > 0);
1518 ASSERT(drawBuffer->Height > 0);
1519 #endif
1520
1521 if (newCtx->FirstTimeCurrent) {
1522 /* set initial viewport and scissor size now */
1523 _mesa_set_viewport(newCtx, 0, 0,
1524 drawBuffer->Width, drawBuffer->Height);
1525 _mesa_set_scissor(newCtx, 0, 0,
1526 drawBuffer->Width, drawBuffer->Height );
1527 check_context_limits(newCtx);
1528 }
1529 }
1530
1531 /* We can use this to help debug user's problems. Tell them to set
1532 * the MESA_INFO env variable before running their app. Then the
1533 * first time each context is made current we'll print some useful
1534 * information.
1535 */
1536 if (newCtx->FirstTimeCurrent) {
1537 if (_mesa_getenv("MESA_INFO")) {
1538 _mesa_print_info();
1539 }
1540 newCtx->FirstTimeCurrent = GL_FALSE;
1541 }
1542 }
1543 }
1544
1545
1546 /**
1547 * Make context 'ctx' share the display lists, textures and programs
1548 * that are associated with 'ctxToShare'.
1549 * Any display lists, textures or programs associated with 'ctx' will
1550 * be deleted if nobody else is sharing them.
1551 */
1552 GLboolean
1553 _mesa_share_state(GLcontext *ctx, GLcontext *ctxToShare)
1554 {
1555 if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1556 ctx->Shared->RefCount--;
1557 if (ctx->Shared->RefCount == 0) {
1558 free_shared_state(ctx, ctx->Shared);
1559 }
1560 ctx->Shared = ctxToShare->Shared;
1561 ctx->Shared->RefCount++;
1562 return GL_TRUE;
1563 }
1564 else {
1565 return GL_FALSE;
1566 }
1567 }
1568
1569
1570
1571 /**
1572 * \return pointer to the current GL context for this thread.
1573 *
1574 * Calls _glapi_get_context(). This isn't the fastest way to get the current
1575 * context. If you need speed, see the #GET_CURRENT_CONTEXT macro in
1576 * context.h.
1577 */
1578 GLcontext *
1579 _mesa_get_current_context( void )
1580 {
1581 return (GLcontext *) _glapi_get_context();
1582 }
1583
1584
1585 /**
1586 * Get context's current API dispatch table.
1587 *
1588 * It'll either be the immediate-mode execute dispatcher or the display list
1589 * compile dispatcher.
1590 *
1591 * \param ctx GL context.
1592 *
1593 * \return pointer to dispatch_table.
1594 *
1595 * Simply returns __GLcontextRec::CurrentDispatch.
1596 */
1597 struct _glapi_table *
1598 _mesa_get_dispatch(GLcontext *ctx)
1599 {
1600 return ctx->CurrentDispatch;
1601 }
1602
1603 /*@}*/
1604
1605
1606 /**********************************************************************/
1607 /** \name Miscellaneous functions */
1608 /**********************************************************************/
1609 /*@{*/
1610
1611 /**
1612 * Record an error.
1613 *
1614 * \param ctx GL context.
1615 * \param error error code.
1616 *
1617 * Records the given error code and call the driver's dd_function_table::Error
1618 * function if defined.
1619 *
1620 * \sa
1621 * This is called via _mesa_error().
1622 */
1623 void
1624 _mesa_record_error(GLcontext *ctx, GLenum error)
1625 {
1626 if (!ctx)
1627 return;
1628
1629 if (ctx->ErrorValue == GL_NO_ERROR) {
1630 ctx->ErrorValue = error;
1631 }
1632
1633 /* Call device driver's error handler, if any. This is used on the Mac. */
1634 if (ctx->Driver.Error) {
1635 ctx->Driver.Error(ctx);
1636 }
1637 }
1638
1639
1640 /**
1641 * Execute glFinish().
1642 *
1643 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1644 * dd_function_table::Finish driver callback, if not NULL.
1645 */
1646 void GLAPIENTRY
1647 _mesa_Finish(void)
1648 {
1649 GET_CURRENT_CONTEXT(ctx);
1650 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1651 if (ctx->Driver.Finish) {
1652 ctx->Driver.Finish(ctx);
1653 }
1654 }
1655
1656
1657 /**
1658 * Execute glFlush().
1659 *
1660 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1661 * dd_function_table::Flush driver callback, if not NULL.
1662 */
1663 void GLAPIENTRY
1664 _mesa_Flush(void)
1665 {
1666 GET_CURRENT_CONTEXT(ctx);
1667 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1668 if (ctx->Driver.Flush) {
1669 ctx->Driver.Flush(ctx);
1670 }
1671 }
1672
1673
1674 /*@}*/