projects / mesa.git / blob
? search:


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