projects / mesa.git / blob
? search:


98c23bbd3a5a62d82eb28931ef3424546ccbea27
[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 #if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
149 #include "shader/program.h"
150 #endif
151 #include "shader/shader_api.h"
152 #if FEATURE_ATI_fragment_shader
153 #include "shader/atifragshader.h"
154 #endif
155 #if _HAVE_FULL_GL
156 #include "math/m_translate.h"
157 #include "math/m_matrix.h"
158 #include "math/m_xform.h"
159 #include "math/mathmod.h"
160 #endif
161
162 #ifdef USE_SPARC_ASM
163 #include "sparc/sparc.h"
164 #endif
165
166 #ifndef MESA_VERBOSE
167 int MESA_VERBOSE = 0;
168 #endif
169
170 #ifndef MESA_DEBUG_FLAGS
171 int MESA_DEBUG_FLAGS = 0;
172 #endif
173
174
175 /* ubyte -> float conversion */
176 GLfloat _mesa_ubyte_to_float_color_tab[256];
177
178
179
180 /**
181 * Swap buffers notification callback.
182 *
183 * \param gc GL context.
184 *
185 * Called by window system just before swapping buffers.
186 * We have to finish any pending rendering.
187 */
188 void
189 _mesa_notifySwapBuffers(__GLcontext *gc)
190 {
191 FLUSH_VERTICES( gc, 0 );
192 }
193
194
195 /**********************************************************************/
196 /** \name GL Visual allocation/destruction */
197 /**********************************************************************/
198 /*@{*/
199
200 /**
201 * Allocates a GLvisual structure and initializes it via
202 * _mesa_initialize_visual().
203 *
204 * \param rgbFlag GL_TRUE for RGB(A) mode, GL_FALSE for Color Index mode.
205 * \param dbFlag double buffering
206 * \param stereoFlag stereo buffer
207 * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
208 * is acceptable but the actual depth type will be GLushort or GLuint as
209 * needed.
210 * \param stencilBits requested minimum bits per stencil buffer value
211 * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.
212 * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
213 * \param redBits number of bits per color component in frame buffer for RGB(A)
214 * mode. We always use 8 in core Mesa though.
215 * \param greenBits same as above.
216 * \param blueBits same as above.
217 * \param alphaBits same as above.
218 * \param numSamples not really used.
219 *
220 * \return pointer to new GLvisual or NULL if requested parameters can't be
221 * met.
222 *
223 * \note Need to add params for level and numAuxBuffers (at least)
224 */
225 GLvisual *
226 _mesa_create_visual( GLboolean rgbFlag,
227 GLboolean dbFlag,
228 GLboolean stereoFlag,
229 GLint redBits,
230 GLint greenBits,
231 GLint blueBits,
232 GLint alphaBits,
233 GLint indexBits,
234 GLint depthBits,
235 GLint stencilBits,
236 GLint accumRedBits,
237 GLint accumGreenBits,
238 GLint accumBlueBits,
239 GLint accumAlphaBits,
240 GLint numSamples )
241 {
242 GLvisual *vis = (GLvisual *) _mesa_calloc(sizeof(GLvisual));
243 if (vis) {
244 if (!_mesa_initialize_visual(vis, rgbFlag, dbFlag, stereoFlag,
245 redBits, greenBits, blueBits, alphaBits,
246 indexBits, depthBits, stencilBits,
247 accumRedBits, accumGreenBits,
248 accumBlueBits, accumAlphaBits,
249 numSamples)) {
250 _mesa_free(vis);
251 return NULL;
252 }
253 }
254 return vis;
255 }
256
257 /**
258 * Makes some sanity checks and fills in the fields of the
259 * GLvisual object with the given parameters. If the caller needs
260 * to set additional fields, he should just probably init the whole GLvisual
261 * object himself.
262 * \return GL_TRUE on success, or GL_FALSE on failure.
263 *
264 * \sa _mesa_create_visual() above for the parameter description.
265 */
266 GLboolean
267 _mesa_initialize_visual( GLvisual *vis,
268 GLboolean rgbFlag,
269 GLboolean dbFlag,
270 GLboolean stereoFlag,
271 GLint redBits,
272 GLint greenBits,
273 GLint blueBits,
274 GLint alphaBits,
275 GLint indexBits,
276 GLint depthBits,
277 GLint stencilBits,
278 GLint accumRedBits,
279 GLint accumGreenBits,
280 GLint accumBlueBits,
281 GLint accumAlphaBits,
282 GLint numSamples )
283 {
284 assert(vis);
285
286 if (depthBits < 0 || depthBits > 32) {
287 return GL_FALSE;
288 }
289 if (stencilBits < 0 || stencilBits > STENCIL_BITS) {
290 return GL_FALSE;
291 }
292 assert(accumRedBits >= 0);
293 assert(accumGreenBits >= 0);
294 assert(accumBlueBits >= 0);
295 assert(accumAlphaBits >= 0);
296
297 vis->rgbMode = rgbFlag;
298 vis->doubleBufferMode = dbFlag;
299 vis->stereoMode = stereoFlag;
300
301 vis->redBits = redBits;
302 vis->greenBits = greenBits;
303 vis->blueBits = blueBits;
304 vis->alphaBits = alphaBits;
305 vis->rgbBits = redBits + greenBits + blueBits;
306
307 vis->indexBits = indexBits;
308 vis->depthBits = depthBits;
309 vis->stencilBits = stencilBits;
310
311 vis->accumRedBits = accumRedBits;
312 vis->accumGreenBits = accumGreenBits;
313 vis->accumBlueBits = accumBlueBits;
314 vis->accumAlphaBits = accumAlphaBits;
315
316 vis->haveAccumBuffer = accumRedBits > 0;
317 vis->haveDepthBuffer = depthBits > 0;
318 vis->haveStencilBuffer = stencilBits > 0;
319
320 vis->numAuxBuffers = 0;
321 vis->level = 0;
322 vis->pixmapMode = 0;
323 vis->sampleBuffers = numSamples > 0 ? 1 : 0;
324 vis->samples = numSamples;
325
326 return GL_TRUE;
327 }
328
329
330 /**
331 * Destroy a visual and free its memory.
332 *
333 * \param vis visual.
334 *
335 * Frees the visual structure.
336 */
337 void
338 _mesa_destroy_visual( GLvisual *vis )
339 {
340 _mesa_free(vis);
341 }
342
343 /*@}*/
344
345
346 /**********************************************************************/
347 /** \name Context allocation, initialization, destroying
348 *
349 * The purpose of the most initialization functions here is to provide the
350 * default state values according to the OpenGL specification.
351 */
352 /**********************************************************************/
353 /*@{*/
354
355 /**
356 * One-time initialization mutex lock.
357 *
358 * \sa Used by one_time_init().
359 */
360 _glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
361
362 /**
363 * Calls all the various one-time-init functions in Mesa.
364 *
365 * While holding a global mutex lock, calls several initialization functions,
366 * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
367 * defined.
368 *
369 * \sa _math_init().
370 */
371 static void
372 one_time_init( GLcontext *ctx )
373 {
374 static GLboolean alreadyCalled = GL_FALSE;
375 (void) ctx;
376 _glthread_LOCK_MUTEX(OneTimeLock);
377 if (!alreadyCalled) {
378 GLuint i;
379
380 /* do some implementation tests */
381 assert( sizeof(GLbyte) == 1 );
382 assert( sizeof(GLubyte) == 1 );
383 assert( sizeof(GLshort) == 2 );
384 assert( sizeof(GLushort) == 2 );
385 assert( sizeof(GLint) == 4 );
386 assert( sizeof(GLuint) == 4 );
387
388 _mesa_init_sqrt_table();
389
390 #if _HAVE_FULL_GL
391 _math_init();
392
393 for (i = 0; i < 256; i++) {
394 _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
395 }
396 #endif
397
398 #ifdef USE_SPARC_ASM
399 _mesa_init_sparc_glapi_relocs();
400 #endif
401 if (_mesa_getenv("MESA_DEBUG")) {
402 _glapi_noop_enable_warnings(GL_TRUE);
403 _glapi_set_warning_func( (_glapi_warning_func) _mesa_warning );
404 }
405 else {
406 _glapi_noop_enable_warnings(GL_FALSE);
407 }
408
409 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
410 _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
411 MESA_VERSION_STRING, __DATE__, __TIME__);
412 #endif
413
414 alreadyCalled = GL_TRUE;
415 }
416 _glthread_UNLOCK_MUTEX(OneTimeLock);
417 }
418
419
420 /**
421 * Allocate and initialize a shared context state structure.
422 * Initializes the display list, texture objects and vertex programs hash
423 * tables, allocates the texture objects. If it runs out of memory, frees
424 * everything already allocated before returning NULL.
425 *
426 * \return pointer to a gl_shared_state structure on success, or NULL on
427 * failure.
428 */
429 static GLboolean
430 alloc_shared_state( GLcontext *ctx )
431 {
432 struct gl_shared_state *ss = CALLOC_STRUCT(gl_shared_state);
433 if (!ss)
434 return GL_FALSE;
435
436 ctx->Shared = ss;
437
438 _glthread_INIT_MUTEX(ss->Mutex);
439
440 ss->DisplayList = _mesa_NewHashTable();
441 ss->TexObjects = _mesa_NewHashTable();
442 ss->Programs = _mesa_NewHashTable();
443
444 #if FEATURE_ARB_vertex_program
445 ss->DefaultVertexProgram = (struct gl_vertex_program *)
446 ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
447 if (!ss->DefaultVertexProgram)
448 goto cleanup;
449 #endif
450 #if FEATURE_ARB_fragment_program
451 ss->DefaultFragmentProgram = (struct gl_fragment_program *)
452 ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
453 if (!ss->DefaultFragmentProgram)
454 goto cleanup;
455 #endif
456 #if FEATURE_ATI_fragment_shader
457 ss->ATIShaders = _mesa_NewHashTable();
458 ss->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0);
459 if (!ss->DefaultFragmentShader)
460 goto cleanup;
461 #endif
462
463 #if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
464 ss->BufferObjects = _mesa_NewHashTable();
465 #endif
466
467 ss->ArrayObjects = _mesa_NewHashTable();
468
469 #if FEATURE_ARB_shader_objects
470 ss->ShaderObjects = _mesa_NewHashTable();
471 #endif
472
473 ss->Default1D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D);
474 if (!ss->Default1D)
475 goto cleanup;
476
477 ss->Default2D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D);
478 if (!ss->Default2D)
479 goto cleanup;
480
481 ss->Default3D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_3D);
482 if (!ss->Default3D)
483 goto cleanup;
484
485 ss->DefaultCubeMap = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_CUBE_MAP_ARB);
486 if (!ss->DefaultCubeMap)
487 goto cleanup;
488
489 ss->DefaultRect = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_RECTANGLE_NV);
490 if (!ss->DefaultRect)
491 goto cleanup;
492
493 ss->Default1DArray = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D_ARRAY_EXT);
494 if (!ss->Default1DArray)
495 goto cleanup;
496
497 ss->Default2DArray = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D_ARRAY_EXT);
498 if (!ss->Default2DArray)
499 goto cleanup;
500
501 /* sanity check */
502 assert(ss->Default1D->RefCount == 1);
503
504 _glthread_INIT_MUTEX(ss->TexMutex);
505 ss->TextureStateStamp = 0;
506
507 #if FEATURE_EXT_framebuffer_object
508 ss->FrameBuffers = _mesa_NewHashTable();
509 if (!ss->FrameBuffers)
510 goto cleanup;
511 ss->RenderBuffers = _mesa_NewHashTable();
512 if (!ss->RenderBuffers)
513 goto cleanup;
514 #endif
515
516 return GL_TRUE;
517
518 cleanup:
519 /* Ran out of memory at some point. Free everything and return NULL */
520 if (ss->DisplayList)
521 _mesa_DeleteHashTable(ss->DisplayList);
522 if (ss->TexObjects)
523 _mesa_DeleteHashTable(ss->TexObjects);
524 if (ss->Programs)
525 _mesa_DeleteHashTable(ss->Programs);
526 #if FEATURE_ARB_vertex_program
527 _mesa_reference_vertprog(ctx, &ss->DefaultVertexProgram, NULL);
528 #endif
529 #if FEATURE_ARB_fragment_program
530 _mesa_reference_fragprog(ctx, &ss->DefaultFragmentProgram, NULL);
531 #endif
532 #if FEATURE_ATI_fragment_shader
533 if (ss->DefaultFragmentShader)
534 _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
535 #endif
536 #if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
537 if (ss->BufferObjects)
538 _mesa_DeleteHashTable(ss->BufferObjects);
539 #endif
540
541 if (ss->ArrayObjects)
542 _mesa_DeleteHashTable (ss->ArrayObjects);
543
544 #if FEATURE_ARB_shader_objects
545 if (ss->ShaderObjects)
546 _mesa_DeleteHashTable (ss->ShaderObjects);
547 #endif
548
549 #if FEATURE_EXT_framebuffer_object
550 if (ss->FrameBuffers)
551 _mesa_DeleteHashTable(ss->FrameBuffers);
552 if (ss->RenderBuffers)
553 _mesa_DeleteHashTable(ss->RenderBuffers);
554 #endif
555
556 if (ss->Default1D)
557 (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D);
558 if (ss->Default2D)
559 (*ctx->Driver.DeleteTexture)(ctx, ss->Default2D);
560 if (ss->Default3D)
561 (*ctx->Driver.DeleteTexture)(ctx, ss->Default3D);
562 if (ss->DefaultCubeMap)
563 (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap);
564 if (ss->DefaultRect)
565 (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect);
566 if (ss->Default1DArray)
567 (*ctx->Driver.DeleteTexture)(ctx, ss->Default1DArray);
568 if (ss->Default2DArray)
569 (*ctx->Driver.DeleteTexture)(ctx, ss->Default2DArray);
570
571 _mesa_free(ss);
572
573 return GL_FALSE;
574 }
575
576
577 /**
578 * Callback for deleting a display list. Called by _mesa_HashDeleteAll().
579 */
580 static void
581 delete_displaylist_cb(GLuint id, void *data, void *userData)
582 {
583 #if FEATURE_dlist
584 struct mesa_display_list *list = (struct mesa_display_list *) data;
585 GLcontext *ctx = (GLcontext *) userData;
586 _mesa_delete_list(ctx, list);
587 #endif
588 }
589
590 /**
591 * Callback for deleting a texture object. Called by _mesa_HashDeleteAll().
592 */
593 static void
594 delete_texture_cb(GLuint id, void *data, void *userData)
595 {
596 struct gl_texture_object *texObj = (struct gl_texture_object *) data;
597 GLcontext *ctx = (GLcontext *) userData;
598 ctx->Driver.DeleteTexture(ctx, texObj);
599 }
600
601 /**
602 * Callback for deleting a program object. Called by _mesa_HashDeleteAll().
603 */
604 static void
605 delete_program_cb(GLuint id, void *data, void *userData)
606 {
607 struct gl_program *prog = (struct gl_program *) data;
608 GLcontext *ctx = (GLcontext *) userData;
609 ASSERT(prog->RefCount == 1); /* should only be referenced by hash table */
610 prog->RefCount = 0; /* now going away */
611 ctx->Driver.DeleteProgram(ctx, prog);
612 }
613
614 /**
615 * Callback for deleting an ATI fragment shader object.
616 * Called by _mesa_HashDeleteAll().
617 */
618 static void
619 delete_fragshader_cb(GLuint id, void *data, void *userData)
620 {
621 struct ati_fragment_shader *shader = (struct ati_fragment_shader *) data;
622 GLcontext *ctx = (GLcontext *) userData;
623 _mesa_delete_ati_fragment_shader(ctx, shader);
624 }
625
626 /**
627 * Callback for deleting a buffer object. Called by _mesa_HashDeleteAll().
628 */
629 static void
630 delete_bufferobj_cb(GLuint id, void *data, void *userData)
631 {
632 struct gl_buffer_object *bufObj = (struct gl_buffer_object *) data;
633 GLcontext *ctx = (GLcontext *) userData;
634 ctx->Driver.DeleteBuffer(ctx, bufObj);
635 }
636
637 /**
638 * Callback for deleting an array object. Called by _mesa_HashDeleteAll().
639 */
640 static void
641 delete_arrayobj_cb(GLuint id, void *data, void *userData)
642 {
643 struct gl_array_object *arrayObj = (struct gl_array_object *) data;
644 GLcontext *ctx = (GLcontext *) userData;
645 _mesa_delete_array_object(ctx, arrayObj);
646 }
647
648 /**
649 * Callback for freeing shader program data. Call it before delete_shader_cb
650 * to avoid memory access error.
651 */
652 static void
653 free_shader_program_data_cb(GLuint id, void *data, void *userData)
654 {
655 GLcontext *ctx = (GLcontext *) userData;
656 struct gl_shader_program *shProg = (struct gl_shader_program *) data;
657
658 if (shProg->Type == GL_SHADER_PROGRAM_MESA) {
659 _mesa_free_shader_program_data(ctx, shProg);
660 }
661 }
662
663 /**
664 * Callback for deleting shader and shader programs objects.
665 * Called by _mesa_HashDeleteAll().
666 */
667 static void
668 delete_shader_cb(GLuint id, void *data, void *userData)
669 {
670 GLcontext *ctx = (GLcontext *) userData;
671 struct gl_shader *sh = (struct gl_shader *) data;
672 if (sh->Type == GL_FRAGMENT_SHADER || sh->Type == GL_VERTEX_SHADER) {
673 _mesa_free_shader(ctx, sh);
674 }
675 else {
676 struct gl_shader_program *shProg = (struct gl_shader_program *) data;
677 ASSERT(shProg->Type == GL_SHADER_PROGRAM_MESA);
678 _mesa_free_shader_program(ctx, shProg);
679 }
680 }
681
682 /**
683 * Callback for deleting a framebuffer object. Called by _mesa_HashDeleteAll()
684 */
685 static void
686 delete_framebuffer_cb(GLuint id, void *data, void *userData)
687 {
688 struct gl_framebuffer *fb = (struct gl_framebuffer *) data;
689 /* The fact that the framebuffer is in the hashtable means its refcount
690 * is one, but we're removing from the hashtable now. So clear refcount.
691 */
692 /*assert(fb->RefCount == 1);*/
693 fb->RefCount = 0;
694
695 /* NOTE: Delete should always be defined but there are two reports
696 * of it being NULL (bugs 13507, 14293). Work-around for now.
697 */
698 if (fb->Delete)
699 fb->Delete(fb);
700 }
701
702 /**
703 * Callback for deleting a renderbuffer object. Called by _mesa_HashDeleteAll()
704 */
705 static void
706 delete_renderbuffer_cb(GLuint id, void *data, void *userData)
707 {
708 struct gl_renderbuffer *rb = (struct gl_renderbuffer *) data;
709 rb->RefCount = 0; /* see comment for FBOs above */
710 if (rb->Delete)
711 rb->Delete(rb);
712 }
713
714
715
716 /**
717 * Deallocate a shared state object and all children structures.
718 *
719 * \param ctx GL context.
720 * \param ss shared state pointer.
721 *
722 * Frees the display lists, the texture objects (calling the driver texture
723 * deletion callback to free its private data) and the vertex programs, as well
724 * as their hash tables.
725 *
726 * \sa alloc_shared_state().
727 */
728 static void
729 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
730 {
731 /*
732 * Free display lists
733 */
734 _mesa_HashDeleteAll(ss->DisplayList, delete_displaylist_cb, ctx);
735 _mesa_DeleteHashTable(ss->DisplayList);
736
737 #if FEATURE_ARB_shader_objects
738 _mesa_HashWalk(ss->ShaderObjects, free_shader_program_data_cb, ctx);
739 _mesa_HashDeleteAll(ss->ShaderObjects, delete_shader_cb, ctx);
740 _mesa_DeleteHashTable(ss->ShaderObjects);
741 #endif
742
743 _mesa_HashDeleteAll(ss->Programs, delete_program_cb, ctx);
744 _mesa_DeleteHashTable(ss->Programs);
745
746 #if FEATURE_ARB_vertex_program
747 _mesa_reference_vertprog(ctx, &ss->DefaultVertexProgram, NULL);
748 #endif
749 #if FEATURE_ARB_fragment_program
750 _mesa_reference_fragprog(ctx, &ss->DefaultFragmentProgram, NULL);
751 #endif
752
753 #if FEATURE_ATI_fragment_shader
754 _mesa_HashDeleteAll(ss->ATIShaders, delete_fragshader_cb, ctx);
755 _mesa_DeleteHashTable(ss->ATIShaders);
756 _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
757 #endif
758
759 #if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
760 _mesa_HashDeleteAll(ss->BufferObjects, delete_bufferobj_cb, ctx);
761 _mesa_DeleteHashTable(ss->BufferObjects);
762 #endif
763
764 _mesa_HashDeleteAll(ss->ArrayObjects, delete_arrayobj_cb, ctx);
765 _mesa_DeleteHashTable(ss->ArrayObjects);
766
767 #if FEATURE_EXT_framebuffer_object
768 _mesa_HashDeleteAll(ss->FrameBuffers, delete_framebuffer_cb, ctx);
769 _mesa_DeleteHashTable(ss->FrameBuffers);
770 _mesa_HashDeleteAll(ss->RenderBuffers, delete_renderbuffer_cb, ctx);
771 _mesa_DeleteHashTable(ss->RenderBuffers);
772 #endif
773
774 /*
775 * Free texture objects (after FBOs since some textures might have
776 * been bound to FBOs).
777 */
778 ASSERT(ctx->Driver.DeleteTexture);
779 /* the default textures */
780 ctx->Driver.DeleteTexture(ctx, ss->Default1D);
781 ctx->Driver.DeleteTexture(ctx, ss->Default2D);
782 ctx->Driver.DeleteTexture(ctx, ss->Default3D);
783 ctx->Driver.DeleteTexture(ctx, ss->DefaultCubeMap);
784 ctx->Driver.DeleteTexture(ctx, ss->DefaultRect);
785 ctx->Driver.DeleteTexture(ctx, ss->Default1DArray);
786 ctx->Driver.DeleteTexture(ctx, ss->Default2DArray);
787 /* all other textures */
788 _mesa_HashDeleteAll(ss->TexObjects, delete_texture_cb, ctx);
789 _mesa_DeleteHashTable(ss->TexObjects);
790
791 _glthread_DESTROY_MUTEX(ss->Mutex);
792
793 _mesa_free(ss);
794 }
795
796
797 /**
798 * Initialize fields of gl_current_attrib (aka ctx->Current.*)
799 */
800 static void
801 _mesa_init_current(GLcontext *ctx)
802 {
803 GLuint i;
804
805 /* Init all to (0,0,0,1) */
806 for (i = 0; i < VERT_ATTRIB_MAX; i++) {
807 ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
808 }
809
810 /* redo special cases: */
811 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );
812 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
813 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
814 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
815 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
816 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
817 }
818
819
820 /**
821 * Init vertex/fragment program native limits from logical limits.
822 */
823 static void
824 init_natives(struct gl_program_constants *prog)
825 {
826 prog->MaxNativeInstructions = prog->MaxInstructions;
827 prog->MaxNativeAluInstructions = prog->MaxAluInstructions;
828 prog->MaxNativeTexInstructions = prog->MaxTexInstructions;
829 prog->MaxNativeTexIndirections = prog->MaxTexIndirections;
830 prog->MaxNativeAttribs = prog->MaxAttribs;
831 prog->MaxNativeTemps = prog->MaxTemps;
832 prog->MaxNativeAddressRegs = prog->MaxAddressRegs;
833 prog->MaxNativeParameters = prog->MaxParameters;
834 }
835
836
837 /**
838 * Initialize fields of gl_constants (aka ctx->Const.*).
839 * Use defaults from config.h. The device drivers will often override
840 * some of these values (such as number of texture units).
841 */
842 static void
843 _mesa_init_constants(GLcontext *ctx)
844 {
845 assert(ctx);
846
847 assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
848 assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
849
850 /* Constants, may be overriden (usually only reduced) by device drivers */
851 ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
852 ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
853 ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
854 ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
855 ctx->Const.MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
856 ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
857 ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
858 ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,
859 ctx->Const.MaxTextureImageUnits);
860 ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
861 ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
862 ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
863 ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
864 ctx->Const.MinPointSize = MIN_POINT_SIZE;
865 ctx->Const.MaxPointSize = MAX_POINT_SIZE;
866 ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
867 ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
868 ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
869 ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
870 ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
871 ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
872 ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
873 ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
874 ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
875 ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
876 ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
877 ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
878 ctx->Const.MaxLights = MAX_LIGHTS;
879 ctx->Const.MaxShininess = 128.0;
880 ctx->Const.MaxSpotExponent = 128.0;
881 ctx->Const.MaxViewportWidth = MAX_WIDTH;
882 ctx->Const.MaxViewportHeight = MAX_HEIGHT;
883 #if FEATURE_ARB_vertex_program
884 ctx->Const.VertexProgram.MaxInstructions = MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS;
885 ctx->Const.VertexProgram.MaxAluInstructions = 0;
886 ctx->Const.VertexProgram.MaxTexInstructions = 0;
887 ctx->Const.VertexProgram.MaxTexIndirections = 0;
888 ctx->Const.VertexProgram.MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
889 ctx->Const.VertexProgram.MaxTemps = MAX_PROGRAM_TEMPS;
890 ctx->Const.VertexProgram.MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
891 ctx->Const.VertexProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
892 ctx->Const.VertexProgram.MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
893 ctx->Const.VertexProgram.MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
894 ctx->Const.VertexProgram.MaxUniformComponents = 4 * MAX_UNIFORMS;
895 init_natives(&ctx->Const.VertexProgram);
896 #endif
897
898 #if FEATURE_ARB_fragment_program
899 ctx->Const.FragmentProgram.MaxInstructions = MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS;
900 ctx->Const.FragmentProgram.MaxAluInstructions = MAX_FRAGMENT_PROGRAM_ALU_INSTRUCTIONS;
901 ctx->Const.FragmentProgram.MaxTexInstructions = MAX_FRAGMENT_PROGRAM_TEX_INSTRUCTIONS;
902 ctx->Const.FragmentProgram.MaxTexIndirections = MAX_FRAGMENT_PROGRAM_TEX_INDIRECTIONS;
903 ctx->Const.FragmentProgram.MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
904 ctx->Const.FragmentProgram.MaxTemps = MAX_PROGRAM_TEMPS;
905 ctx->Const.FragmentProgram.MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
906 ctx->Const.FragmentProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
907 ctx->Const.FragmentProgram.MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
908 ctx->Const.FragmentProgram.MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
909 ctx->Const.FragmentProgram.MaxUniformComponents = 4 * MAX_UNIFORMS;
910 init_natives(&ctx->Const.FragmentProgram);
911 #endif
912 ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
913 ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
914
915 /* CheckArrayBounds is overriden by drivers/x11 for X server */
916 ctx->Const.CheckArrayBounds = GL_FALSE;
917
918 /* GL_ARB_draw_buffers */
919 ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
920
921 /* GL_OES_read_format */
922 ctx->Const.ColorReadFormat = GL_RGBA;
923 ctx->Const.ColorReadType = GL_UNSIGNED_BYTE;
924
925 #if FEATURE_EXT_framebuffer_object
926 ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
927 ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
928 #endif
929
930 #if FEATURE_ARB_vertex_shader
931 ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
932 ctx->Const.MaxVarying = MAX_VARYING;
933 #endif
934
935 /* sanity checks */
936 ASSERT(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,
937 ctx->Const.MaxTextureCoordUnits));
938 ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
939 ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
940
941 ASSERT(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
942 ASSERT(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
943 ASSERT(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);
944 ASSERT(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);
945 }
946
947
948 /**
949 * Do some sanity checks on the limits/constants for the given context.
950 * Only called the first time a context is bound.
951 */
952 static void
953 check_context_limits(GLcontext *ctx)
954 {
955 /* Many context limits/constants are limited by the size of
956 * internal arrays.
957 */
958 assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
959 assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
960 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
961 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
962
963 /* number of coord units cannot be greater than number of image units */
964 assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits);
965
966 assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);
967 assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);
968
969 /* make sure largest texture image is <= MAX_WIDTH in size */
970 assert((1 << (ctx->Const.MaxTextureLevels -1 )) <= MAX_WIDTH);
971 assert((1 << (ctx->Const.MaxCubeTextureLevels -1 )) <= MAX_WIDTH);
972 assert((1 << (ctx->Const.Max3DTextureLevels -1 )) <= MAX_WIDTH);
973
974 assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
975
976 /* XXX probably add more tests */
977 }
978
979
980 /**
981 * Initialize the attribute groups in a GL context.
982 *
983 * \param ctx GL context.
984 *
985 * Initializes all the attributes, calling the respective <tt>init*</tt>
986 * functions for the more complex data structures.
987 */
988 static GLboolean
989 init_attrib_groups(GLcontext *ctx)
990 {
991 assert(ctx);
992
993 /* Constants */
994 _mesa_init_constants( ctx );
995
996 /* Extensions */
997 _mesa_init_extensions( ctx );
998
999 /* Attribute Groups */
1000 #if FEATURE_accum
1001 _mesa_init_accum( ctx );
1002 #endif
1003 #if FEATURE_attrib_stack
1004 _mesa_init_attrib( ctx );
1005 #endif
1006 _mesa_init_buffer_objects( ctx );
1007 _mesa_init_color( ctx );
1008 #if FEATURE_colortable
1009 _mesa_init_colortables( ctx );
1010 #endif
1011 _mesa_init_current( ctx );
1012 _mesa_init_depth( ctx );
1013 _mesa_init_debug( ctx );
1014 #if FEATURE_dlist
1015 _mesa_init_display_list( ctx );
1016 #endif
1017 #if FEATURE_evaluators
1018 _mesa_init_eval( ctx );
1019 #endif
1020 _mesa_init_fbobjects( ctx );
1021 #if FEATURE_feedback
1022 _mesa_init_feedback( ctx );
1023 #else
1024 ctx->RenderMode = GL_RENDER;
1025 #endif
1026 _mesa_init_fog( ctx );
1027 #if FEATURE_histogram
1028 _mesa_init_histogram( ctx );
1029 #endif
1030 _mesa_init_hint( ctx );
1031 _mesa_init_line( ctx );
1032 _mesa_init_lighting( ctx );
1033 _mesa_init_matrix( ctx );
1034 _mesa_init_multisample( ctx );
1035 _mesa_init_pixel( ctx );
1036 _mesa_init_pixelstore( ctx );
1037 _mesa_init_point( ctx );
1038 _mesa_init_polygon( ctx );
1039 _mesa_init_program( ctx );
1040 #if FEATURE_ARB_occlusion_query
1041 _mesa_init_query( ctx );
1042 #endif
1043 #if FEATURE_drawpix
1044 _mesa_init_rastpos( ctx );
1045 #endif
1046 _mesa_init_scissor( ctx );
1047 _mesa_init_shader_state( ctx );
1048 _mesa_init_stencil( ctx );
1049 _mesa_init_transform( ctx );
1050 _mesa_init_varray( ctx );
1051 _mesa_init_viewport( ctx );
1052
1053 if (!_mesa_init_texture( ctx ))
1054 return GL_FALSE;
1055
1056 #if FEATURE_texture_s3tc
1057 _mesa_init_texture_s3tc( ctx );
1058 #endif
1059 #if FEATURE_texture_fxt1
1060 _mesa_init_texture_fxt1( ctx );
1061 #endif
1062
1063 /* Miscellaneous */
1064 ctx->NewState = _NEW_ALL;
1065 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1066
1067 return GL_TRUE;
1068 }
1069
1070
1071 /**
1072 * Update default objects in a GL context with respect to shared state.
1073 *
1074 * \param ctx GL context.
1075 *
1076 * Removes references to old default objects, (texture objects, program
1077 * objects, etc.) and changes to reference those from the current shared
1078 * state.
1079 */
1080 static GLboolean
1081 update_default_objects(GLcontext *ctx)
1082 {
1083 assert(ctx);
1084
1085 _mesa_update_default_objects_program(ctx);
1086 _mesa_update_default_objects_texture(ctx);
1087 _mesa_update_default_objects_buffer_objects(ctx);
1088
1089 return GL_TRUE;
1090 }
1091
1092
1093 /**
1094 * This is the default function we plug into all dispatch table slots
1095 * This helps prevents a segfault when someone calls a GL function without
1096 * first checking if the extension's supported.
1097 */
1098 static int
1099 generic_nop(void)
1100 {
1101 _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)");
1102 return 0;
1103 }
1104
1105
1106 /**
1107 * Allocate and initialize a new dispatch table.
1108 */
1109 static struct _glapi_table *
1110 alloc_dispatch_table(void)
1111 {
1112 /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1113 * In practice, this'll be the same for stand-alone Mesa. But for DRI
1114 * Mesa we do this to accomodate different versions of libGL and various
1115 * DRI drivers.
1116 */
1117 GLint numEntries = MAX2(_glapi_get_dispatch_table_size(),
1118 sizeof(struct _glapi_table) / sizeof(_glapi_proc));
1119 struct _glapi_table *table =
1120 (struct _glapi_table *) _mesa_malloc(numEntries * sizeof(_glapi_proc));
1121 if (table) {
1122 _glapi_proc *entry = (_glapi_proc *) table;
1123 GLint i;
1124 for (i = 0; i < numEntries; i++) {
1125 entry[i] = (_glapi_proc) generic_nop;
1126 }
1127 }
1128 return table;
1129 }
1130
1131
1132 /**
1133 * Initialize a GLcontext struct (rendering context).
1134 *
1135 * This includes allocating all the other structs and arrays which hang off of
1136 * the context by pointers.
1137 * Note that the driver needs to pass in its dd_function_table here since
1138 * we need to at least call driverFunctions->NewTextureObject to create the
1139 * default texture objects.
1140 *
1141 * Called by _mesa_create_context().
1142 *
1143 * Performs the imports and exports callback tables initialization, and
1144 * miscellaneous one-time initializations. If no shared context is supplied one
1145 * is allocated, and increase its reference count. Setups the GL API dispatch
1146 * tables. Initialize the TNL module. Sets the maximum Z buffer depth.
1147 * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1148 * for debug flags.
1149 *
1150 * \param ctx the context to initialize
1151 * \param visual describes the visual attributes for this context
1152 * \param share_list points to context to share textures, display lists,
1153 * etc with, or NULL
1154 * \param driverFunctions table of device driver functions for this context
1155 * to use
1156 * \param driverContext pointer to driver-specific context data
1157 */
1158 GLboolean
1159 _mesa_initialize_context(GLcontext *ctx,
1160 const GLvisual *visual,
1161 GLcontext *share_list,
1162 const struct dd_function_table *driverFunctions,
1163 void *driverContext)
1164 {
1165 ASSERT(driverContext);
1166 assert(driverFunctions->NewTextureObject);
1167 assert(driverFunctions->FreeTexImageData);
1168
1169 /* misc one-time initializations */
1170 one_time_init(ctx);
1171
1172 ctx->Visual = *visual;
1173 ctx->DrawBuffer = NULL;
1174 ctx->ReadBuffer = NULL;
1175 ctx->WinSysDrawBuffer = NULL;
1176 ctx->WinSysReadBuffer = NULL;
1177
1178 /* Plug in driver functions and context pointer here.
1179 * This is important because when we call alloc_shared_state() below
1180 * we'll call ctx->Driver.NewTextureObject() to create the default
1181 * textures.
1182 */
1183 ctx->Driver = *driverFunctions;
1184 ctx->DriverCtx = driverContext;
1185
1186 if (share_list) {
1187 /* share state with another context */
1188 ctx->Shared = share_list->Shared;
1189 }
1190 else {
1191 /* allocate new, unshared state */
1192 if (!alloc_shared_state( ctx )) {
1193 return GL_FALSE;
1194 }
1195 }
1196 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1197 ctx->Shared->RefCount++;
1198 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1199
1200 if (!init_attrib_groups( ctx )) {
1201 free_shared_state(ctx, ctx->Shared);
1202 return GL_FALSE;
1203 }
1204
1205 /* setup the API dispatch tables */
1206 ctx->Exec = alloc_dispatch_table();
1207 ctx->Save = alloc_dispatch_table();
1208 if (!ctx->Exec || !ctx->Save) {
1209 free_shared_state(ctx, ctx->Shared);
1210 if (ctx->Exec)
1211 _mesa_free(ctx->Exec);
1212 }
1213 #if FEATURE_dispatch
1214 _mesa_init_exec_table(ctx->Exec);
1215 #endif
1216 ctx->CurrentDispatch = ctx->Exec;
1217 #if FEATURE_dlist
1218 _mesa_init_dlist_table(ctx->Save);
1219 _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
1220 #endif
1221 /* Neutral tnl module stuff */
1222 _mesa_init_exec_vtxfmt( ctx );
1223 ctx->TnlModule.Current = NULL;
1224 ctx->TnlModule.SwapCount = 0;
1225
1226 ctx->FragmentProgram._MaintainTexEnvProgram
1227 = (_mesa_getenv("MESA_TEX_PROG") != NULL);
1228
1229 ctx->VertexProgram._MaintainTnlProgram
1230 = (_mesa_getenv("MESA_TNL_PROG") != NULL);
1231 if (ctx->VertexProgram._MaintainTnlProgram) {
1232 /* this is required... */
1233 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1234 }
1235
1236 #ifdef FEATURE_extra_context_init
1237 _mesa_initialize_context_extra(ctx);
1238 #endif
1239
1240 ctx->FirstTimeCurrent = GL_TRUE;
1241
1242 return GL_TRUE;
1243 }
1244
1245
1246 /**
1247 * Allocate and initialize a GLcontext structure.
1248 * Note that the driver needs to pass in its dd_function_table here since
1249 * we need to at least call driverFunctions->NewTextureObject to initialize
1250 * the rendering context.
1251 *
1252 * \param visual a GLvisual pointer (we copy the struct contents)
1253 * \param share_list another context to share display lists with or NULL
1254 * \param driverFunctions points to the dd_function_table into which the
1255 * driver has plugged in all its special functions.
1256 * \param driverCtx points to the device driver's private context state
1257 *
1258 * \return pointer to a new __GLcontextRec or NULL if error.
1259 */
1260 GLcontext *
1261 _mesa_create_context(const GLvisual *visual,
1262 GLcontext *share_list,
1263 const struct dd_function_table *driverFunctions,
1264 void *driverContext)
1265 {
1266 GLcontext *ctx;
1267
1268 ASSERT(visual);
1269 ASSERT(driverContext);
1270
1271 ctx = (GLcontext *) _mesa_calloc(sizeof(GLcontext));
1272 if (!ctx)
1273 return NULL;
1274
1275 if (_mesa_initialize_context(ctx, visual, share_list,
1276 driverFunctions, driverContext)) {
1277 return ctx;
1278 }
1279 else {
1280 _mesa_free(ctx);
1281 return NULL;
1282 }
1283 }
1284
1285
1286 /**
1287 * Free the data associated with the given context.
1288 *
1289 * But doesn't free the GLcontext struct itself.
1290 *
1291 * \sa _mesa_initialize_context() and init_attrib_groups().
1292 */
1293 void
1294 _mesa_free_context_data( GLcontext *ctx )
1295 {
1296 if (!_mesa_get_current_context()){
1297 /* No current context, but we may need one in order to delete
1298 * texture objs, etc. So temporarily bind the context now.
1299 */
1300 _mesa_make_current(ctx, NULL, NULL);
1301 }
1302
1303 /* unreference WinSysDraw/Read buffers */
1304 _mesa_unreference_framebuffer(&ctx->WinSysDrawBuffer);
1305 _mesa_unreference_framebuffer(&ctx->WinSysReadBuffer);
1306 _mesa_unreference_framebuffer(&ctx->DrawBuffer);
1307 _mesa_unreference_framebuffer(&ctx->ReadBuffer);
1308
1309 _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
1310 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
1311 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL);
1312
1313 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
1314 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
1315 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
1316
1317 _mesa_free_attrib_data(ctx);
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 _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1635 }
1636 if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {
1637 _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1638 }
1639
1640 /* XXX only set this flag if we're really changing the draw/read
1641 * framebuffer bindings.
1642 */
1643 newCtx->NewState |= _NEW_BUFFERS;
1644
1645 #if 1
1646 /* We want to get rid of these lines: */
1647
1648 #if _HAVE_FULL_GL
1649 if (!drawBuffer->Initialized) {
1650 initialize_framebuffer_size(newCtx, drawBuffer);
1651 }
1652 if (readBuffer != drawBuffer && !readBuffer->Initialized) {
1653 initialize_framebuffer_size(newCtx, readBuffer);
1654 }
1655
1656 _mesa_resizebuffers(newCtx);
1657 #endif
1658
1659 #else
1660 /* We want the drawBuffer and readBuffer to be initialized by
1661 * the driver.
1662 * This generally means the Width and Height match the actual
1663 * window size and the renderbuffers (both hardware and software
1664 * based) are allocated to match. The later can generally be
1665 * done with a call to _mesa_resize_framebuffer().
1666 *
1667 * It's theoretically possible for a buffer to have zero width
1668 * or height, but for now, assert check that the driver did what's
1669 * expected of it.
1670 */
1671 ASSERT(drawBuffer->Width > 0);
1672 ASSERT(drawBuffer->Height > 0);
1673 #endif
1674
1675 if (newCtx->FirstTimeCurrent) {
1676 /* set initial viewport and scissor size now */
1677 _mesa_set_viewport(newCtx, 0, 0,
1678 drawBuffer->Width, drawBuffer->Height);
1679 _mesa_set_scissor(newCtx, 0, 0,
1680 drawBuffer->Width, drawBuffer->Height );
1681 check_context_limits(newCtx);
1682 }
1683 }
1684
1685 /* We can use this to help debug user's problems. Tell them to set
1686 * the MESA_INFO env variable before running their app. Then the
1687 * first time each context is made current we'll print some useful
1688 * information.
1689 */
1690 if (newCtx->FirstTimeCurrent) {
1691 if (_mesa_getenv("MESA_INFO")) {
1692 _mesa_print_info();
1693 }
1694 newCtx->FirstTimeCurrent = GL_FALSE;
1695 }
1696 }
1697 }
1698
1699
1700 /**
1701 * Make context 'ctx' share the display lists, textures and programs
1702 * that are associated with 'ctxToShare'.
1703 * Any display lists, textures or programs associated with 'ctx' will
1704 * be deleted if nobody else is sharing them.
1705 */
1706 GLboolean
1707 _mesa_share_state(GLcontext *ctx, GLcontext *ctxToShare)
1708 {
1709 if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1710 struct gl_shared_state *oldSharedState = ctx->Shared;
1711
1712 ctx->Shared = ctxToShare->Shared;
1713 ctx->Shared->RefCount++;
1714
1715 update_default_objects(ctx);
1716
1717 oldSharedState->RefCount--;
1718 if (oldSharedState->RefCount == 0) {
1719 free_shared_state(ctx, oldSharedState);
1720 }
1721
1722 return GL_TRUE;
1723 }
1724 else {
1725 return GL_FALSE;
1726 }
1727 }
1728
1729
1730
1731 /**
1732 * \return pointer to the current GL context for this thread.
1733 *
1734 * Calls _glapi_get_context(). This isn't the fastest way to get the current
1735 * context. If you need speed, see the #GET_CURRENT_CONTEXT macro in
1736 * context.h.
1737 */
1738 GLcontext *
1739 _mesa_get_current_context( void )
1740 {
1741 return (GLcontext *) _glapi_get_context();
1742 }
1743
1744
1745 /**
1746 * Get context's current API dispatch table.
1747 *
1748 * It'll either be the immediate-mode execute dispatcher or the display list
1749 * compile dispatcher.
1750 *
1751 * \param ctx GL context.
1752 *
1753 * \return pointer to dispatch_table.
1754 *
1755 * Simply returns __GLcontextRec::CurrentDispatch.
1756 */
1757 struct _glapi_table *
1758 _mesa_get_dispatch(GLcontext *ctx)
1759 {
1760 return ctx->CurrentDispatch;
1761 }
1762
1763 /*@}*/
1764
1765
1766 /**********************************************************************/
1767 /** \name Miscellaneous functions */
1768 /**********************************************************************/
1769 /*@{*/
1770
1771 /**
1772 * Record an error.
1773 *
1774 * \param ctx GL context.
1775 * \param error error code.
1776 *
1777 * Records the given error code and call the driver's dd_function_table::Error
1778 * function if defined.
1779 *
1780 * \sa
1781 * This is called via _mesa_error().
1782 */
1783 void
1784 _mesa_record_error(GLcontext *ctx, GLenum error)
1785 {
1786 if (!ctx)
1787 return;
1788
1789 if (ctx->ErrorValue == GL_NO_ERROR) {
1790 ctx->ErrorValue = error;
1791 }
1792
1793 /* Call device driver's error handler, if any. This is used on the Mac. */
1794 if (ctx->Driver.Error) {
1795 ctx->Driver.Error(ctx);
1796 }
1797 }
1798
1799
1800 /**
1801 * Execute glFinish().
1802 *
1803 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1804 * dd_function_table::Finish driver callback, if not NULL.
1805 */
1806 void GLAPIENTRY
1807 _mesa_Finish(void)
1808 {
1809 GET_CURRENT_CONTEXT(ctx);
1810 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1811 if (ctx->Driver.Finish) {
1812 ctx->Driver.Finish(ctx);
1813 }
1814 }
1815
1816
1817 /**
1818 * Execute glFlush().
1819 *
1820 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1821 * dd_function_table::Flush driver callback, if not NULL.
1822 */
1823 void GLAPIENTRY
1824 _mesa_Flush(void)
1825 {
1826 GET_CURRENT_CONTEXT(ctx);
1827 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1828 if (ctx->Driver.Flush) {
1829 ctx->Driver.Flush(ctx);
1830 }
1831 }
1832
1833
1834 /*@}*/