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