Debian Codegraph @

nx-X11/extras/Mesa/src/mesa/main/context.c

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