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