projects / mesa.git / blob
? search:


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