projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
disable _glapi_set_warning_func() call as it's not present in older libGLs
[mesa.git] / src / mesa / main / context.c
1 /* $Id: context.c,v 1.182 2002/10/10 00:22:13 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 4.1
6 *
7 * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28 #ifdef PC_HEADER
29 #include "all.h"
30 #else
31 #include "glheader.h"
32 #include "buffers.h"
33 #include "clip.h"
34 #include "colortab.h"
35 #include "context.h"
36 #include "dlist.h"
37 #include "eval.h"
38 #include "enums.h"
39 #include "extensions.h"
40 #include "fog.h"
41 #include "get.h"
42 #include "glthread.h"
43 #include "hash.h"
44 #include "light.h"
45 #include "macros.h"
46 #include "mem.h"
47 #include "mmath.h"
48 #include "simple_list.h"
49 #include "state.h"
50 #include "teximage.h"
51 #include "texobj.h"
52 #include "texstate.h"
53 #include "mtypes.h"
54 #include "varray.h"
55 #include "vpstate.h"
56 #include "vtxfmt.h"
57 #include "math/m_translate.h"
58 #include "math/m_matrix.h"
59 #include "math/m_xform.h"
60 #include "math/mathmod.h"
61 #endif
62
63 #if defined(MESA_TRACE)
64 #include "Trace/tr_context.h"
65 #include "Trace/tr_wrapper.h"
66 #endif
67
68 #ifdef USE_SPARC_ASM
69 #include "SPARC/sparc.h"
70 #endif
71
72 #ifndef MESA_VERBOSE
73 int MESA_VERBOSE = 0;
74 #endif
75
76 #ifndef MESA_DEBUG_FLAGS
77 int MESA_DEBUG_FLAGS = 0;
78 #endif
79
80 /* XFree86 stuff */
81 #ifdef getenv
82 #undef getenv
83 #endif
84 #ifdef calloc
85 #undef calloc
86 extern void *calloc(size_t, size_t);
87 #endif
88 #ifdef free
89 #undef free
90 extern void free(void *);
91 #endif
92
93
94 static void
95 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss );
96
97
98 /**********************************************************************/
99 /***** OpenGL SI-style interface (new in Mesa 3.5) *****/
100 /**********************************************************************/
101
102 /* Called by window system/device driver (via gc->exports.destroyCurrent())
103 * when the rendering context is to be destroyed.
104 */
105 GLboolean
106 _mesa_destroyContext(__GLcontext *gc)
107 {
108 if (gc) {
109 _mesa_free_context_data(gc);
110 (*gc->imports.free)(gc, gc);
111 }
112 return GL_TRUE;
113 }
114
115 /* Called by window system/device driver (via gc->exports.loseCurrent())
116 * when the rendering context is made non-current.
117 */
118 GLboolean
119 _mesa_loseCurrent(__GLcontext *gc)
120 {
121 /* XXX unbind context from thread */
122 return GL_TRUE;
123 }
124
125 /* Called by window system/device driver (via gc->exports.makeCurrent())
126 * when the rendering context is made current.
127 */
128 GLboolean
129 _mesa_makeCurrent(__GLcontext *gc)
130 {
131 /* XXX bind context to thread */
132 return GL_TRUE;
133 }
134
135 /* Called by window system/device driver - yadda, yadda, yadda.
136 * See above comments.
137 */
138 GLboolean
139 _mesa_shareContext(__GLcontext *gc, __GLcontext *gcShare)
140 {
141 if (gc && gcShare && gc->Shared && gcShare->Shared) {
142 gc->Shared->RefCount--;
143 if (gc->Shared->RefCount == 0) {
144 free_shared_state(gc, gc->Shared);
145 }
146 gc->Shared = gcShare->Shared;
147 gc->Shared->RefCount++;
148 return GL_TRUE;
149 }
150 else {
151 return GL_FALSE;
152 }
153 }
154
155 GLboolean
156 _mesa_copyContext(__GLcontext *dst, const __GLcontext *src, GLuint mask)
157 {
158 if (dst && src) {
159 _mesa_copy_context( src, dst, mask );
160 return GL_TRUE;
161 }
162 else {
163 return GL_FALSE;
164 }
165 }
166
167 GLboolean
168 _mesa_forceCurrent(__GLcontext *gc)
169 {
170 return GL_TRUE;
171 }
172
173 GLboolean
174 _mesa_notifyResize(__GLcontext *gc)
175 {
176 GLint x, y;
177 GLuint width, height;
178 __GLdrawablePrivate *d = gc->imports.getDrawablePrivate(gc);
179 if (!d || !d->getDrawableSize)
180 return GL_FALSE;
181 d->getDrawableSize( d, &x, &y, &width, &height );
182 /* update viewport, resize software buffers, etc. */
183 return GL_TRUE;
184 }
185
186 void
187 _mesa_notifyDestroy(__GLcontext *gc)
188 {
189 }
190
191 /* Called by window system just before swapping buffers.
192 * We have to finish any pending rendering.
193 */
194 void
195 _mesa_notifySwapBuffers(__GLcontext *gc)
196 {
197 FLUSH_VERTICES( gc, 0 );
198 }
199
200 struct __GLdispatchStateRec *
201 _mesa_dispatchExec(__GLcontext *gc)
202 {
203 return NULL;
204 }
205
206 void
207 _mesa_beginDispatchOverride(__GLcontext *gc)
208 {
209 }
210
211 void
212 _mesa_endDispatchOverride(__GLcontext *gc)
213 {
214 }
215
216 /* Setup the exports. The window system will call these functions
217 * when it needs Mesa to do something.
218 * NOTE: Device drivers should override these functions! For example,
219 * the Xlib driver should plug in the XMesa*-style functions into this
220 * structure. The XMesa-style functions should then call the _mesa_*
221 * version of these functions. This is an approximation to OO design
222 * (inheritance and virtual functions).
223 */
224 static void
225 _mesa_init_default_exports(__GLexports *exports)
226 {
227 exports->destroyContext = _mesa_destroyContext;
228 exports->loseCurrent = _mesa_loseCurrent;
229 exports->makeCurrent = _mesa_makeCurrent;
230 exports->shareContext = _mesa_shareContext;
231 exports->copyContext = _mesa_copyContext;
232 exports->forceCurrent = _mesa_forceCurrent;
233 exports->notifyResize = _mesa_notifyResize;
234 exports->notifyDestroy = _mesa_notifyDestroy;
235 exports->notifySwapBuffers = _mesa_notifySwapBuffers;
236 exports->dispatchExec = _mesa_dispatchExec;
237 exports->beginDispatchOverride = _mesa_beginDispatchOverride;
238 exports->endDispatchOverride = _mesa_endDispatchOverride;
239 }
240
241
242
243 /* exported OpenGL SI interface */
244 __GLcontext *
245 __glCoreCreateContext(__GLimports *imports, __GLcontextModes *modes)
246 {
247 GLcontext *ctx;
248
249 ctx = (GLcontext *) (*imports->calloc)(NULL, 1, sizeof(GLcontext));
250 if (ctx == NULL) {
251 return NULL;
252 }
253 ctx->Driver.CurrentExecPrimitive=0; /* XXX why is this here??? */
254 ctx->imports = *imports;
255 _mesa_init_default_exports(&(ctx->exports));
256
257 _mesa_initialize_visual(&ctx->Visual,
258 modes->rgbMode,
259 modes->doubleBufferMode,
260 modes->stereoMode,
261 modes->redBits,
262 modes->greenBits,
263 modes->blueBits,
264 modes->alphaBits,
265 modes->indexBits,
266 modes->depthBits,
267 modes->stencilBits,
268 modes->accumRedBits,
269 modes->accumGreenBits,
270 modes->accumBlueBits,
271 modes->accumAlphaBits,
272 0);
273
274 _mesa_initialize_context(ctx, &ctx->Visual, NULL, imports);
275
276 return ctx;
277 }
278
279
280 /* exported OpenGL SI interface */
281 void
282 __glCoreNopDispatch(void)
283 {
284 #if 0
285 /* SI */
286 __gl_dispatch = __glNopDispatchState;
287 #else
288 /* Mesa */
289 _glapi_set_dispatch(NULL);
290 #endif
291 }
292
293
294 /**********************************************************************/
295 /***** GL Visual allocation/destruction *****/
296 /**********************************************************************/
297
298
299 /*
300 * Allocate a new GLvisual object.
301 * Input: rgbFlag - GL_TRUE=RGB(A) mode, GL_FALSE=Color Index mode
302 * dbFlag - double buffering?
303 * stereoFlag - stereo buffer?
304 * depthBits - requested bits per depth buffer value
305 * Any value in [0, 32] is acceptable but the actual
306 * depth type will be GLushort or GLuint as needed.
307 * stencilBits - requested minimum bits per stencil buffer value
308 * accumBits - requested minimum bits per accum buffer component
309 * indexBits - number of bits per pixel if rgbFlag==GL_FALSE
310 * red/green/blue/alphaBits - number of bits per color component
311 * in frame buffer for RGB(A) mode.
312 * We always use 8 in core Mesa though.
313 * Return: pointer to new GLvisual or NULL if requested parameters can't
314 * be met.
315 */
316 GLvisual *
317 _mesa_create_visual( GLboolean rgbFlag,
318 GLboolean dbFlag,
319 GLboolean stereoFlag,
320 GLint redBits,
321 GLint greenBits,
322 GLint blueBits,
323 GLint alphaBits,
324 GLint indexBits,
325 GLint depthBits,
326 GLint stencilBits,
327 GLint accumRedBits,
328 GLint accumGreenBits,
329 GLint accumBlueBits,
330 GLint accumAlphaBits,
331 GLint numSamples )
332 {
333 GLvisual *vis = (GLvisual *) CALLOC( sizeof(GLvisual) );
334 if (vis) {
335 if (!_mesa_initialize_visual(vis, rgbFlag, dbFlag, stereoFlag,
336 redBits, greenBits, blueBits, alphaBits,
337 indexBits, depthBits, stencilBits,
338 accumRedBits, accumGreenBits,
339 accumBlueBits, accumAlphaBits,
340 numSamples)) {
341 FREE(vis);
342 return NULL;
343 }
344 }
345 return vis;
346 }
347
348
349 /*
350 * Initialize the fields of the given GLvisual.
351 * Input: see _mesa_create_visual() above.
352 * Return: GL_TRUE = success
353 * GL_FALSE = failure.
354 */
355 GLboolean
356 _mesa_initialize_visual( GLvisual *vis,
357 GLboolean rgbFlag,
358 GLboolean dbFlag,
359 GLboolean stereoFlag,
360 GLint redBits,
361 GLint greenBits,
362 GLint blueBits,
363 GLint alphaBits,
364 GLint indexBits,
365 GLint depthBits,
366 GLint stencilBits,
367 GLint accumRedBits,
368 GLint accumGreenBits,
369 GLint accumBlueBits,
370 GLint accumAlphaBits,
371 GLint numSamples )
372 {
373 (void) numSamples;
374
375 assert(vis);
376
377 /* This is to catch bad values from device drivers not updated for
378 * Mesa 3.3. Some device drivers just passed 1. That's a REALLY
379 * bad value now (a 1-bit depth buffer!?!).
380 */
381 assert(depthBits == 0 || depthBits > 1);
382
383 if (depthBits < 0 || depthBits > 32) {
384 return GL_FALSE;
385 }
386 if (stencilBits < 0 || stencilBits > (GLint) (8 * sizeof(GLstencil))) {
387 return GL_FALSE;
388 }
389 if (accumRedBits < 0 || accumRedBits > (GLint) (8 * sizeof(GLaccum))) {
390 return GL_FALSE;
391 }
392 if (accumGreenBits < 0 || accumGreenBits > (GLint) (8 * sizeof(GLaccum))) {
393 return GL_FALSE;
394 }
395 if (accumBlueBits < 0 || accumBlueBits > (GLint) (8 * sizeof(GLaccum))) {
396 return GL_FALSE;
397 }
398 if (accumAlphaBits < 0 || accumAlphaBits > (GLint) (8 * sizeof(GLaccum))) {
399 return GL_FALSE;
400 }
401
402 vis->rgbMode = rgbFlag;
403 vis->doubleBufferMode = dbFlag;
404 vis->stereoMode = stereoFlag;
405 vis->redBits = redBits;
406 vis->greenBits = greenBits;
407 vis->blueBits = blueBits;
408 vis->alphaBits = alphaBits;
409
410 vis->indexBits = indexBits;
411 vis->depthBits = depthBits;
412 vis->accumRedBits = (accumRedBits > 0) ? (8 * sizeof(GLaccum)) : 0;
413 vis->accumGreenBits = (accumGreenBits > 0) ? (8 * sizeof(GLaccum)) : 0;
414 vis->accumBlueBits = (accumBlueBits > 0) ? (8 * sizeof(GLaccum)) : 0;
415 vis->accumAlphaBits = (accumAlphaBits > 0) ? (8 * sizeof(GLaccum)) : 0;
416 vis->stencilBits = (stencilBits > 0) ? (8 * sizeof(GLstencil)) : 0;
417
418 return GL_TRUE;
419 }
420
421
422 void
423 _mesa_destroy_visual( GLvisual *vis )
424 {
425 FREE(vis);
426 }
427
428
429 /**********************************************************************/
430 /***** GL Framebuffer allocation/destruction *****/
431 /**********************************************************************/
432
433
434 /*
435 * Create a new framebuffer. A GLframebuffer is a struct which
436 * encapsulates the depth, stencil and accum buffers and related
437 * parameters.
438 * Input: visual - a GLvisual pointer (we copy the struct contents)
439 * softwareDepth - create/use a software depth buffer?
440 * softwareStencil - create/use a software stencil buffer?
441 * softwareAccum - create/use a software accum buffer?
442 * softwareAlpha - create/use a software alpha buffer?
443 * Return: pointer to new GLframebuffer struct or NULL if error.
444 */
445 GLframebuffer *
446 _mesa_create_framebuffer( const GLvisual *visual,
447 GLboolean softwareDepth,
448 GLboolean softwareStencil,
449 GLboolean softwareAccum,
450 GLboolean softwareAlpha )
451 {
452 GLframebuffer *buffer = CALLOC_STRUCT(gl_frame_buffer);
453 assert(visual);
454 if (buffer) {
455 _mesa_initialize_framebuffer(buffer, visual,
456 softwareDepth, softwareStencil,
457 softwareAccum, softwareAlpha );
458 }
459 return buffer;
460 }
461
462
463 /*
464 * Initialize a GLframebuffer object.
465 * Input: See _mesa_create_framebuffer() above.
466 */
467 void
468 _mesa_initialize_framebuffer( GLframebuffer *buffer,
469 const GLvisual *visual,
470 GLboolean softwareDepth,
471 GLboolean softwareStencil,
472 GLboolean softwareAccum,
473 GLboolean softwareAlpha )
474 {
475 assert(buffer);
476 assert(visual);
477
478 BZERO(buffer, sizeof(GLframebuffer));
479
480 /* sanity checks */
481 if (softwareDepth ) {
482 assert(visual->depthBits > 0);
483 }
484 if (softwareStencil) {
485 assert(visual->stencilBits > 0);
486 }
487 if (softwareAccum) {
488 assert(visual->rgbMode);
489 assert(visual->accumRedBits > 0);
490 assert(visual->accumGreenBits > 0);
491 assert(visual->accumBlueBits > 0);
492 }
493 if (softwareAlpha) {
494 assert(visual->rgbMode);
495 assert(visual->alphaBits > 0);
496 }
497
498 buffer->Visual = *visual;
499 buffer->UseSoftwareDepthBuffer = softwareDepth;
500 buffer->UseSoftwareStencilBuffer = softwareStencil;
501 buffer->UseSoftwareAccumBuffer = softwareAccum;
502 buffer->UseSoftwareAlphaBuffers = softwareAlpha;
503 }
504
505
506 /*
507 * Free a framebuffer struct and its buffers.
508 */
509 void
510 _mesa_destroy_framebuffer( GLframebuffer *buffer )
511 {
512 if (buffer) {
513 _mesa_free_framebuffer_data(buffer);
514 FREE(buffer);
515 }
516 }
517
518
519 /*
520 * Free the data hanging off of <buffer>, but not <buffer> itself.
521 */
522 void
523 _mesa_free_framebuffer_data( GLframebuffer *buffer )
524 {
525 if (!buffer)
526 return;
527
528 if (buffer->DepthBuffer) {
529 MESA_PBUFFER_FREE( buffer->DepthBuffer );
530 buffer->DepthBuffer = NULL;
531 }
532 if (buffer->Accum) {
533 MESA_PBUFFER_FREE( buffer->Accum );
534 buffer->Accum = NULL;
535 }
536 if (buffer->Stencil) {
537 MESA_PBUFFER_FREE( buffer->Stencil );
538 buffer->Stencil = NULL;
539 }
540 if (buffer->FrontLeftAlpha) {
541 MESA_PBUFFER_FREE( buffer->FrontLeftAlpha );
542 buffer->FrontLeftAlpha = NULL;
543 }
544 if (buffer->BackLeftAlpha) {
545 MESA_PBUFFER_FREE( buffer->BackLeftAlpha );
546 buffer->BackLeftAlpha = NULL;
547 }
548 if (buffer->FrontRightAlpha) {
549 MESA_PBUFFER_FREE( buffer->FrontRightAlpha );
550 buffer->FrontRightAlpha = NULL;
551 }
552 if (buffer->BackRightAlpha) {
553 MESA_PBUFFER_FREE( buffer->BackRightAlpha );
554 buffer->BackRightAlpha = NULL;
555 }
556 }
557
558
559
560 /**********************************************************************/
561 /***** Context allocation, initialization, destroying *****/
562 /**********************************************************************/
563
564
565 _glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
566
567
568 /*
569 * This function just calls all the various one-time-init functions in Mesa.
570 */
571 static void
572 one_time_init( GLcontext *ctx )
573 {
574 static GLboolean alreadyCalled = GL_FALSE;
575 _glthread_LOCK_MUTEX(OneTimeLock);
576 if (!alreadyCalled) {
577 /* do some implementation tests */
578 assert( sizeof(GLbyte) == 1 );
579 assert( sizeof(GLshort) >= 2 );
580 assert( sizeof(GLint) >= 4 );
581 assert( sizeof(GLubyte) == 1 );
582 assert( sizeof(GLushort) >= 2 );
583 assert( sizeof(GLuint) >= 4 );
584
585 _mesa_init_lists();
586
587 _math_init();
588 _mesa_init_math();
589
590 #ifdef USE_SPARC_ASM
591 _mesa_init_sparc_glapi_relocs();
592 #endif
593 if (ctx->imports.getenv(ctx, "MESA_DEBUG")) {
594 _glapi_noop_enable_warnings(GL_TRUE);
595 #ifndef GLX_DIRECT_RENDERING
596 /* libGL from before 2002/06/28 don't have this function. Someday,
597 * when newer libGL libs are common, remove the #ifdef test. This
598 * only serves to print warnings when calling undefined GL functions.
599 */
600 _glapi_set_warning_func( (_glapi_warning_func) _mesa_warning );
601 #endif
602 }
603 else {
604 _glapi_noop_enable_warnings(GL_FALSE);
605 }
606
607 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
608 _mesa_debug(ctx, "Mesa DEBUG build %s %s\n", __DATE__, __TIME__);
609 #endif
610
611 alreadyCalled = GL_TRUE;
612 }
613 _glthread_UNLOCK_MUTEX(OneTimeLock);
614 }
615
616
617 static void
618 init_matrix_stack( struct matrix_stack *stack,
619 GLuint maxDepth, GLuint dirtyFlag )
620 {
621 GLuint i;
622
623 stack->Depth = 0;
624 stack->MaxDepth = maxDepth;
625 stack->DirtyFlag = dirtyFlag;
626 /* The stack */
627 stack->Stack = (GLmatrix *) CALLOC(maxDepth * sizeof(GLmatrix));
628 for (i = 0; i < maxDepth; i++) {
629 _math_matrix_ctr(&stack->Stack[i]);
630 _math_matrix_alloc_inv(&stack->Stack[i]);
631 }
632 stack->Top = stack->Stack;
633 }
634
635
636 static void
637 free_matrix_stack( struct matrix_stack *stack )
638 {
639 GLuint i;
640 for (i = 0; i < stack->MaxDepth; i++) {
641 _math_matrix_dtr(&stack->Stack[i]);
642 }
643 FREE(stack->Stack);
644 stack->Stack = stack->Top = NULL;
645 }
646
647
648 /*
649 * Allocate and initialize a shared context state structure.
650 */
651 static struct gl_shared_state *
652 alloc_shared_state( void )
653 {
654 struct gl_shared_state *ss;
655 GLboolean outOfMemory;
656
657 ss = CALLOC_STRUCT(gl_shared_state);
658 if (!ss)
659 return NULL;
660
661 _glthread_INIT_MUTEX(ss->Mutex);
662
663 ss->DisplayList = _mesa_NewHashTable();
664 ss->TexObjects = _mesa_NewHashTable();
665 ss->VertexPrograms = _mesa_NewHashTable();
666
667 /* Default Texture objects */
668 outOfMemory = GL_FALSE;
669
670 ss->Default1D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_1D);
671 if (!ss->Default1D) {
672 outOfMemory = GL_TRUE;
673 }
674
675 ss->Default2D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_2D);
676 if (!ss->Default2D) {
677 outOfMemory = GL_TRUE;
678 }
679
680 ss->Default3D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_3D);
681 if (!ss->Default3D) {
682 outOfMemory = GL_TRUE;
683 }
684
685 ss->DefaultCubeMap = _mesa_alloc_texture_object(ss, 0,
686 GL_TEXTURE_CUBE_MAP_ARB);
687 if (!ss->DefaultCubeMap) {
688 outOfMemory = GL_TRUE;
689 }
690
691 ss->DefaultRect = _mesa_alloc_texture_object(ss, 0,
692 GL_TEXTURE_RECTANGLE_NV);
693 if (!ss->DefaultRect) {
694 outOfMemory = GL_TRUE;
695 }
696
697 if (!ss->DisplayList || !ss->TexObjects || !ss->VertexPrograms
698 || outOfMemory) {
699 /* Ran out of memory at some point. Free everything and return NULL */
700 if (ss->DisplayList)
701 _mesa_DeleteHashTable(ss->DisplayList);
702 if (ss->TexObjects)
703 _mesa_DeleteHashTable(ss->TexObjects);
704 if (ss->VertexPrograms)
705 _mesa_DeleteHashTable(ss->VertexPrograms);
706 if (ss->Default1D)
707 _mesa_free_texture_object(ss, ss->Default1D);
708 if (ss->Default2D)
709 _mesa_free_texture_object(ss, ss->Default2D);
710 if (ss->Default3D)
711 _mesa_free_texture_object(ss, ss->Default3D);
712 if (ss->DefaultCubeMap)
713 _mesa_free_texture_object(ss, ss->DefaultCubeMap);
714 if (ss->DefaultRect)
715 _mesa_free_texture_object(ss, ss->DefaultRect);
716 FREE(ss);
717 return NULL;
718 }
719 else {
720 return ss;
721 }
722 }
723
724
725 /*
726 * Deallocate a shared state context and all children structures.
727 */
728 static void
729 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
730 {
731 /* Free display lists */
732 while (1) {
733 GLuint list = _mesa_HashFirstEntry(ss->DisplayList);
734 if (list) {
735 _mesa_destroy_list(ctx, list);
736 }
737 else {
738 break;
739 }
740 }
741 _mesa_DeleteHashTable(ss->DisplayList);
742
743 /* Free texture objects */
744 while (ss->TexObjectList) {
745 if (ctx->Driver.DeleteTexture)
746 (*ctx->Driver.DeleteTexture)( ctx, ss->TexObjectList );
747 /* this function removes from linked list too! */
748 _mesa_free_texture_object(ss, ss->TexObjectList);
749 }
750 _mesa_DeleteHashTable(ss->TexObjects);
751
752 /* Free vertex programs */
753 while (1) {
754 GLuint prog = _mesa_HashFirstEntry(ss->VertexPrograms);
755 if (prog) {
756 _mesa_delete_program(ctx, prog);
757 }
758 else {
759 break;
760 }
761 }
762 _mesa_DeleteHashTable(ss->VertexPrograms);
763
764 FREE(ss);
765 }
766
767
768
769 /*
770 * Initialize the nth light. Note that the defaults for light 0 are
771 * different than the other lights.
772 */
773 static void
774 init_light( struct gl_light *l, GLuint n )
775 {
776 make_empty_list( l );
777
778 ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 );
779 if (n==0) {
780 ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 );
781 ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 );
782 }
783 else {
784 ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 );
785 ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 );
786 }
787 ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 );
788 ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 );
789 l->SpotExponent = 0.0;
790 _mesa_invalidate_spot_exp_table( l );
791 l->SpotCutoff = 180.0;
792 l->_CosCutoff = 0.0; /* KW: -ve values not admitted */
793 l->ConstantAttenuation = 1.0;
794 l->LinearAttenuation = 0.0;
795 l->QuadraticAttenuation = 0.0;
796 l->Enabled = GL_FALSE;
797 }
798
799
800
801 static void
802 init_lightmodel( struct gl_lightmodel *lm )
803 {
804 ASSIGN_4V( lm->Ambient, 0.2F, 0.2F, 0.2F, 1.0F );
805 lm->LocalViewer = GL_FALSE;
806 lm->TwoSide = GL_FALSE;
807 lm->ColorControl = GL_SINGLE_COLOR;
808 }
809
810
811 static void
812 init_material( struct gl_material *m )
813 {
814 ASSIGN_4V( m->Ambient, 0.2F, 0.2F, 0.2F, 1.0F );
815 ASSIGN_4V( m->Diffuse, 0.8F, 0.8F, 0.8F, 1.0F );
816 ASSIGN_4V( m->Specular, 0.0F, 0.0F, 0.0F, 1.0F );
817 ASSIGN_4V( m->Emission, 0.0F, 0.0F, 0.0F, 1.0F );
818 m->Shininess = 0.0;
819 m->AmbientIndex = 0;
820 m->DiffuseIndex = 1;
821 m->SpecularIndex = 1;
822 }
823
824
825
826 static void
827 init_texture_unit( GLcontext *ctx, GLuint unit )
828 {
829 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
830
831 texUnit->EnvMode = GL_MODULATE;
832 texUnit->CombineModeRGB = GL_MODULATE;
833 texUnit->CombineModeA = GL_MODULATE;
834 texUnit->CombineSourceRGB[0] = GL_TEXTURE;
835 texUnit->CombineSourceRGB[1] = GL_PREVIOUS_EXT;
836 texUnit->CombineSourceRGB[2] = GL_CONSTANT_EXT;
837 texUnit->CombineSourceA[0] = GL_TEXTURE;
838 texUnit->CombineSourceA[1] = GL_PREVIOUS_EXT;
839 texUnit->CombineSourceA[2] = GL_CONSTANT_EXT;
840 texUnit->CombineOperandRGB[0] = GL_SRC_COLOR;
841 texUnit->CombineOperandRGB[1] = GL_SRC_COLOR;
842 texUnit->CombineOperandRGB[2] = GL_SRC_ALPHA;
843 texUnit->CombineOperandA[0] = GL_SRC_ALPHA;
844 texUnit->CombineOperandA[1] = GL_SRC_ALPHA;
845 texUnit->CombineOperandA[2] = GL_SRC_ALPHA;
846 texUnit->CombineScaleShiftRGB = 0;
847 texUnit->CombineScaleShiftA = 0;
848
849 ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
850 texUnit->TexGenEnabled = 0;
851 texUnit->GenModeS = GL_EYE_LINEAR;
852 texUnit->GenModeT = GL_EYE_LINEAR;
853 texUnit->GenModeR = GL_EYE_LINEAR;
854 texUnit->GenModeQ = GL_EYE_LINEAR;
855 texUnit->_GenBitS = TEXGEN_EYE_LINEAR;
856 texUnit->_GenBitT = TEXGEN_EYE_LINEAR;
857 texUnit->_GenBitR = TEXGEN_EYE_LINEAR;
858 texUnit->_GenBitQ = TEXGEN_EYE_LINEAR;
859
860 /* Yes, these plane coefficients are correct! */
861 ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 );
862 ASSIGN_4V( texUnit->ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 );
863 ASSIGN_4V( texUnit->ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 );
864 ASSIGN_4V( texUnit->ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 );
865 ASSIGN_4V( texUnit->EyePlaneS, 1.0, 0.0, 0.0, 0.0 );
866 ASSIGN_4V( texUnit->EyePlaneT, 0.0, 1.0, 0.0, 0.0 );
867 ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 );
868 ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 );
869
870 texUnit->Current1D = ctx->Shared->Default1D;
871 texUnit->Current2D = ctx->Shared->Default2D;
872 texUnit->Current3D = ctx->Shared->Default3D;
873 texUnit->CurrentCubeMap = ctx->Shared->DefaultCubeMap;
874 texUnit->CurrentRect = ctx->Shared->DefaultRect;
875 }
876
877
878
879
880 /* Initialize a 1-D evaluator map */
881 static void
882 init_1d_map( struct gl_1d_map *map, int n, const float *initial )
883 {
884 map->Order = 1;
885 map->u1 = 0.0;
886 map->u2 = 1.0;
887 map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat));
888 if (map->Points) {
889 GLint i;
890 for (i=0;i<n;i++)
891 map->Points[i] = initial[i];
892 }
893 }
894
895
896 /* Initialize a 2-D evaluator map */
897 static void
898 init_2d_map( struct gl_2d_map *map, int n, const float *initial )
899 {
900 map->Uorder = 1;
901 map->Vorder = 1;
902 map->u1 = 0.0;
903 map->u2 = 1.0;
904 map->v1 = 0.0;
905 map->v2 = 1.0;
906 map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat));
907 if (map->Points) {
908 GLint i;
909 for (i=0;i<n;i++)
910 map->Points[i] = initial[i];
911 }
912 }
913
914
915 /*
916 * Initialize the attribute groups in a GLcontext.
917 */
918 static void
919 init_attrib_groups( GLcontext *ctx )
920 {
921 GLuint i;
922
923 assert(ctx);
924
925 assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
926 assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
927
928 /* Constants, may be overriden by device drivers */
929 ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
930 ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
931 ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
932 ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
933 ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
934 ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
935 ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
936 ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
937 ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
938 ctx->Const.MinPointSize = MIN_POINT_SIZE;
939 ctx->Const.MaxPointSize = MAX_POINT_SIZE;
940 ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
941 ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
942 ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
943 ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
944 ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
945 ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
946 ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
947 ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
948 ctx->Const.NumAuxBuffers = NUM_AUX_BUFFERS;
949 ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
950 ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
951 ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
952 ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
953 ctx->Const.MaxLights = MAX_LIGHTS;
954
955 /* Initialize matrix stacks */
956 init_matrix_stack(&ctx->ModelviewMatrixStack, MAX_MODELVIEW_STACK_DEPTH,
957 _NEW_MODELVIEW);
958 init_matrix_stack(&ctx->ProjectionMatrixStack, MAX_PROJECTION_STACK_DEPTH,
959 _NEW_PROJECTION);
960 init_matrix_stack(&ctx->ColorMatrixStack, MAX_COLOR_STACK_DEPTH,
961 _NEW_COLOR_MATRIX);
962 for (i = 0; i < MAX_TEXTURE_UNITS; i++)
963 init_matrix_stack(&ctx->TextureMatrixStack[i], MAX_TEXTURE_STACK_DEPTH,
964 _NEW_TEXTURE_MATRIX);
965 for (i = 0; i < MAX_PROGRAM_MATRICES; i++)
966 init_matrix_stack(&ctx->ProgramMatrixStack[i], MAX_PROGRAM_STACK_DEPTH,
967 _NEW_TRACK_MATRIX);
968 ctx->CurrentStack = &ctx->ModelviewMatrixStack;
969
970 /* Init combined Modelview*Projection matrix */
971 _math_matrix_ctr( &ctx->_ModelProjectMatrix );
972
973 /* Accumulate buffer group */
974 ASSIGN_4V( ctx->Accum.ClearColor, 0.0, 0.0, 0.0, 0.0 );
975
976 /* Color buffer group */
977 ctx->Color.IndexMask = 0xffffffff;
978 ctx->Color.ColorMask[0] = 0xff;
979 ctx->Color.ColorMask[1] = 0xff;
980 ctx->Color.ColorMask[2] = 0xff;
981 ctx->Color.ColorMask[3] = 0xff;
982 ctx->Color.ClearIndex = 0;
983 ASSIGN_4V( ctx->Color.ClearColor, 0, 0, 0, 0 );
984 ctx->Color.DrawBuffer = GL_FRONT;
985 ctx->Color.AlphaEnabled = GL_FALSE;
986 ctx->Color.AlphaFunc = GL_ALWAYS;
987 ctx->Color.AlphaRef = 0;
988 ctx->Color.BlendEnabled = GL_FALSE;
989 ctx->Color.BlendSrcRGB = GL_ONE;
990 ctx->Color.BlendDstRGB = GL_ZERO;
991 ctx->Color.BlendSrcA = GL_ONE;
992 ctx->Color.BlendDstA = GL_ZERO;
993 ctx->Color.BlendEquation = GL_FUNC_ADD_EXT;
994 ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );
995 ctx->Color.IndexLogicOpEnabled = GL_FALSE;
996 ctx->Color.ColorLogicOpEnabled = GL_FALSE;
997 ctx->Color.LogicOp = GL_COPY;
998 ctx->Color.DitherFlag = GL_TRUE;
999
1000 /* Current group */
1001 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 0.0, 0.0, 0.0, 0.0 );
1002 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 0.0 );
1003 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
1004 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 0.0 );
1005 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_FOG], 0.0, 0.0, 0.0, 0.0 );
1006 for (i = 0; i < MAX_TEXTURE_UNITS; i++)
1007 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i], 0.0, 0.0, 0.0, 1.0 );
1008 ctx->Current.Index = 1;
1009 ctx->Current.EdgeFlag = GL_TRUE;
1010
1011 ASSIGN_4V( ctx->Current.RasterPos, 0.0, 0.0, 0.0, 1.0 );
1012 ctx->Current.RasterDistance = 0.0;
1013 ASSIGN_4V( ctx->Current.RasterColor, 1.0, 1.0, 1.0, 1.0 );
1014 ctx->Current.RasterIndex = 1;
1015 for (i=0; i<MAX_TEXTURE_UNITS; i++)
1016 ASSIGN_4V( ctx->Current.RasterTexCoords[i], 0.0, 0.0, 0.0, 1.0 );
1017 ctx->Current.RasterPosValid = GL_TRUE;
1018
1019
1020 /* Depth buffer group */
1021 ctx->Depth.Test = GL_FALSE;
1022 ctx->Depth.Clear = 1.0;
1023 ctx->Depth.Func = GL_LESS;
1024 ctx->Depth.Mask = GL_TRUE;
1025 ctx->Depth.OcclusionTest = GL_FALSE;
1026
1027 /* Evaluators group */
1028 ctx->Eval.Map1Color4 = GL_FALSE;
1029 ctx->Eval.Map1Index = GL_FALSE;
1030 ctx->Eval.Map1Normal = GL_FALSE;
1031 ctx->Eval.Map1TextureCoord1 = GL_FALSE;
1032 ctx->Eval.Map1TextureCoord2 = GL_FALSE;
1033 ctx->Eval.Map1TextureCoord3 = GL_FALSE;
1034 ctx->Eval.Map1TextureCoord4 = GL_FALSE;
1035 ctx->Eval.Map1Vertex3 = GL_FALSE;
1036 ctx->Eval.Map1Vertex4 = GL_FALSE;
1037 MEMSET(ctx->Eval.Map1Attrib, 0, sizeof(ctx->Eval.Map1Attrib));
1038 ctx->Eval.Map2Color4 = GL_FALSE;
1039 ctx->Eval.Map2Index = GL_FALSE;
1040 ctx->Eval.Map2Normal = GL_FALSE;
1041 ctx->Eval.Map2TextureCoord1 = GL_FALSE;
1042 ctx->Eval.Map2TextureCoord2 = GL_FALSE;
1043 ctx->Eval.Map2TextureCoord3 = GL_FALSE;
1044 ctx->Eval.Map2TextureCoord4 = GL_FALSE;
1045 ctx->Eval.Map2Vertex3 = GL_FALSE;
1046 ctx->Eval.Map2Vertex4 = GL_FALSE;
1047 MEMSET(ctx->Eval.Map2Attrib, 0, sizeof(ctx->Eval.Map2Attrib));
1048 ctx->Eval.AutoNormal = GL_FALSE;
1049 ctx->Eval.MapGrid1un = 1;
1050 ctx->Eval.MapGrid1u1 = 0.0;
1051 ctx->Eval.MapGrid1u2 = 1.0;
1052 ctx->Eval.MapGrid2un = 1;
1053 ctx->Eval.MapGrid2vn = 1;
1054 ctx->Eval.MapGrid2u1 = 0.0;
1055 ctx->Eval.MapGrid2u2 = 1.0;
1056 ctx->Eval.MapGrid2v1 = 0.0;
1057 ctx->Eval.MapGrid2v2 = 1.0;
1058
1059 /* Evaluator data */
1060 {
1061 static GLfloat vertex[4] = { 0.0, 0.0, 0.0, 1.0 };
1062 static GLfloat normal[3] = { 0.0, 0.0, 1.0 };
1063 static GLfloat index[1] = { 1.0 };
1064 static GLfloat color[4] = { 1.0, 1.0, 1.0, 1.0 };
1065 static GLfloat texcoord[4] = { 0.0, 0.0, 0.0, 1.0 };
1066 static GLfloat attrib[4] = { 0.0, 0.0, 0.0, 1.0 };
1067
1068 init_1d_map( &ctx->EvalMap.Map1Vertex3, 3, vertex );
1069 init_1d_map( &ctx->EvalMap.Map1Vertex4, 4, vertex );
1070 init_1d_map( &ctx->EvalMap.Map1Index, 1, index );
1071 init_1d_map( &ctx->EvalMap.Map1Color4, 4, color );
1072 init_1d_map( &ctx->EvalMap.Map1Normal, 3, normal );
1073 init_1d_map( &ctx->EvalMap.Map1Texture1, 1, texcoord );
1074 init_1d_map( &ctx->EvalMap.Map1Texture2, 2, texcoord );
1075 init_1d_map( &ctx->EvalMap.Map1Texture3, 3, texcoord );
1076 init_1d_map( &ctx->EvalMap.Map1Texture4, 4, texcoord );
1077 for (i = 0; i < 16; i++)
1078 init_1d_map( ctx->EvalMap.Map1Attrib + i, 4, attrib );
1079
1080 init_2d_map( &ctx->EvalMap.Map2Vertex3, 3, vertex );
1081 init_2d_map( &ctx->EvalMap.Map2Vertex4, 4, vertex );
1082 init_2d_map( &ctx->EvalMap.Map2Index, 1, index );
1083 init_2d_map( &ctx->EvalMap.Map2Color4, 4, color );
1084 init_2d_map( &ctx->EvalMap.Map2Normal, 3, normal );
1085 init_2d_map( &ctx->EvalMap.Map2Texture1, 1, texcoord );
1086 init_2d_map( &ctx->EvalMap.Map2Texture2, 2, texcoord );
1087 init_2d_map( &ctx->EvalMap.Map2Texture3, 3, texcoord );
1088 init_2d_map( &ctx->EvalMap.Map2Texture4, 4, texcoord );
1089 for (i = 0; i < 16; i++)
1090 init_2d_map( ctx->EvalMap.Map2Attrib + i, 4, attrib );
1091 }
1092
1093 /* Fog group */
1094 ctx->Fog.Enabled = GL_FALSE;
1095 ctx->Fog.Mode = GL_EXP;
1096 ASSIGN_4V( ctx->Fog.Color, 0.0, 0.0, 0.0, 0.0 );
1097 ctx->Fog.Index = 0.0;
1098 ctx->Fog.Density = 1.0;
1099 ctx->Fog.Start = 0.0;
1100 ctx->Fog.End = 1.0;
1101 ctx->Fog.ColorSumEnabled = GL_FALSE;
1102 ctx->Fog.FogCoordinateSource = GL_FRAGMENT_DEPTH_EXT;
1103
1104 /* Hint group */
1105 ctx->Hint.PerspectiveCorrection = GL_DONT_CARE;
1106 ctx->Hint.PointSmooth = GL_DONT_CARE;
1107 ctx->Hint.LineSmooth = GL_DONT_CARE;
1108 ctx->Hint.PolygonSmooth = GL_DONT_CARE;
1109 ctx->Hint.Fog = GL_DONT_CARE;
1110 ctx->Hint.ClipVolumeClipping = GL_DONT_CARE;
1111 ctx->Hint.TextureCompression = GL_DONT_CARE;
1112 ctx->Hint.GenerateMipmap = GL_DONT_CARE;
1113
1114 /* Histogram group */
1115 ctx->Histogram.Width = 0;
1116 ctx->Histogram.Format = GL_RGBA;
1117 ctx->Histogram.Sink = GL_FALSE;
1118 ctx->Histogram.RedSize = 0;
1119 ctx->Histogram.GreenSize = 0;
1120 ctx->Histogram.BlueSize = 0;
1121 ctx->Histogram.AlphaSize = 0;
1122 ctx->Histogram.LuminanceSize = 0;
1123 for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
1124 ctx->Histogram.Count[i][0] = 0;
1125 ctx->Histogram.Count[i][1] = 0;
1126 ctx->Histogram.Count[i][2] = 0;
1127 ctx->Histogram.Count[i][3] = 0;
1128 }
1129
1130 /* Min/Max group */
1131 ctx->MinMax.Format = GL_RGBA;
1132 ctx->MinMax.Sink = GL_FALSE;
1133 ctx->MinMax.Min[RCOMP] = 1000; ctx->MinMax.Max[RCOMP] = -1000;
1134 ctx->MinMax.Min[GCOMP] = 1000; ctx->MinMax.Max[GCOMP] = -1000;
1135 ctx->MinMax.Min[BCOMP] = 1000; ctx->MinMax.Max[BCOMP] = -1000;
1136 ctx->MinMax.Min[ACOMP] = 1000; ctx->MinMax.Max[ACOMP] = -1000;
1137
1138 /* Extensions */
1139 _mesa_extensions_ctr( ctx );
1140
1141 /* Lighting group */
1142 for (i=0;i<MAX_LIGHTS;i++) {
1143 init_light( &ctx->Light.Light[i], i );
1144 }
1145 make_empty_list( &ctx->Light.EnabledList );
1146
1147 init_lightmodel( &ctx->Light.Model );
1148 init_material( &ctx->Light.Material[0] );
1149 init_material( &ctx->Light.Material[1] );
1150 ctx->Light.ShadeModel = GL_SMOOTH;
1151 ctx->Light.Enabled = GL_FALSE;
1152 ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK;
1153 ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE;
1154 ctx->Light.ColorMaterialBitmask = _mesa_material_bitmask( ctx,
1155 GL_FRONT_AND_BACK,
1156 GL_AMBIENT_AND_DIFFUSE, ~0, 0 );
1157
1158 ctx->Light.ColorMaterialEnabled = GL_FALSE;
1159
1160 /* Lighting miscellaneous */
1161 ctx->_ShineTabList = MALLOC_STRUCT( gl_shine_tab );
1162 make_empty_list( ctx->_ShineTabList );
1163 for (i = 0 ; i < 10 ; i++) {
1164 struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab );
1165 s->shininess = -1;
1166 s->refcount = 0;
1167 insert_at_tail( ctx->_ShineTabList, s );
1168 }
1169
1170
1171 /* Line group */
1172 ctx->Line.SmoothFlag = GL_FALSE;
1173 ctx->Line.StippleFlag = GL_FALSE;
1174 ctx->Line.Width = 1.0;
1175 ctx->Line._Width = 1.0;
1176 ctx->Line.StipplePattern = 0xffff;
1177 ctx->Line.StippleFactor = 1;
1178
1179 /* Display List group */
1180 ctx->List.ListBase = 0;
1181
1182 /* Multisample */
1183 ctx->Multisample.Enabled = GL_FALSE;
1184 ctx->Multisample.SampleAlphaToCoverage = GL_FALSE;
1185 ctx->Multisample.SampleAlphaToOne = GL_FALSE;
1186 ctx->Multisample.SampleCoverage = GL_FALSE;
1187 ctx->Multisample.SampleCoverageValue = 1.0;
1188 ctx->Multisample.SampleCoverageInvert = GL_FALSE;
1189
1190 /* Pixel group */
1191 ctx->Pixel.RedBias = 0.0;
1192 ctx->Pixel.RedScale = 1.0;
1193 ctx->Pixel.GreenBias = 0.0;
1194 ctx->Pixel.GreenScale = 1.0;
1195 ctx->Pixel.BlueBias = 0.0;
1196 ctx->Pixel.BlueScale = 1.0;
1197 ctx->Pixel.AlphaBias = 0.0;
1198 ctx->Pixel.AlphaScale = 1.0;
1199 ctx->Pixel.DepthBias = 0.0;
1200 ctx->Pixel.DepthScale = 1.0;
1201 ctx->Pixel.IndexOffset = 0;
1202 ctx->Pixel.IndexShift = 0;
1203 ctx->Pixel.ZoomX = 1.0;
1204 ctx->Pixel.ZoomY = 1.0;
1205 ctx->Pixel.MapColorFlag = GL_FALSE;
1206 ctx->Pixel.MapStencilFlag = GL_FALSE;
1207 ctx->Pixel.MapStoSsize = 1;
1208 ctx->Pixel.MapItoIsize = 1;
1209 ctx->Pixel.MapItoRsize = 1;
1210 ctx->Pixel.MapItoGsize = 1;
1211 ctx->Pixel.MapItoBsize = 1;
1212 ctx->Pixel.MapItoAsize = 1;
1213 ctx->Pixel.MapRtoRsize = 1;
1214 ctx->Pixel.MapGtoGsize = 1;
1215 ctx->Pixel.MapBtoBsize = 1;
1216 ctx->Pixel.MapAtoAsize = 1;
1217 ctx->Pixel.MapStoS[0] = 0;
1218 ctx->Pixel.MapItoI[0] = 0;
1219 ctx->Pixel.MapItoR[0] = 0.0;
1220 ctx->Pixel.MapItoG[0] = 0.0;
1221 ctx->Pixel.MapItoB[0] = 0.0;
1222 ctx->Pixel.MapItoA[0] = 0.0;
1223 ctx->Pixel.MapItoR8[0] = 0;
1224 ctx->Pixel.MapItoG8[0] = 0;
1225 ctx->Pixel.MapItoB8[0] = 0;
1226 ctx->Pixel.MapItoA8[0] = 0;
1227 ctx->Pixel.MapRtoR[0] = 0.0;
1228 ctx->Pixel.MapGtoG[0] = 0.0;
1229 ctx->Pixel.MapBtoB[0] = 0.0;
1230 ctx->Pixel.MapAtoA[0] = 0.0;
1231 ctx->Pixel.HistogramEnabled = GL_FALSE;
1232 ctx->Pixel.MinMaxEnabled = GL_FALSE;
1233 ctx->Pixel.PixelTextureEnabled = GL_FALSE;
1234 ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
1235 ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
1236 ASSIGN_4V(ctx->Pixel.PostColorMatrixScale, 1.0, 1.0, 1.0, 1.0);
1237 ASSIGN_4V(ctx->Pixel.PostColorMatrixBias, 0.0, 0.0, 0.0, 0.0);
1238 ASSIGN_4V(ctx->Pixel.ColorTableScale, 1.0, 1.0, 1.0, 1.0);
1239 ASSIGN_4V(ctx->Pixel.ColorTableBias, 0.0, 0.0, 0.0, 0.0);
1240 ASSIGN_4V(ctx->Pixel.PCCTscale, 1.0, 1.0, 1.0, 1.0);
1241 ASSIGN_4V(ctx->Pixel.PCCTbias, 0.0, 0.0, 0.0, 0.0);
1242 ASSIGN_4V(ctx->Pixel.PCMCTscale, 1.0, 1.0, 1.0, 1.0);
1243 ASSIGN_4V(ctx->Pixel.PCMCTbias, 0.0, 0.0, 0.0, 0.0);
1244 ctx->Pixel.ColorTableEnabled = GL_FALSE;
1245 ctx->Pixel.PostConvolutionColorTableEnabled = GL_FALSE;
1246 ctx->Pixel.PostColorMatrixColorTableEnabled = GL_FALSE;
1247 ctx->Pixel.Convolution1DEnabled = GL_FALSE;
1248 ctx->Pixel.Convolution2DEnabled = GL_FALSE;
1249 ctx->Pixel.Separable2DEnabled = GL_FALSE;
1250 for (i = 0; i < 3; i++) {
1251 ASSIGN_4V(ctx->Pixel.ConvolutionBorderColor[i], 0.0, 0.0, 0.0, 0.0);
1252 ctx->Pixel.ConvolutionBorderMode[i] = GL_REDUCE;
1253 ASSIGN_4V(ctx->Pixel.ConvolutionFilterScale[i], 1.0, 1.0, 1.0, 1.0);
1254 ASSIGN_4V(ctx->Pixel.ConvolutionFilterBias[i], 0.0, 0.0, 0.0, 0.0);
1255 }
1256 for (i = 0; i < MAX_CONVOLUTION_WIDTH * MAX_CONVOLUTION_WIDTH * 4; i++) {
1257 ctx->Convolution1D.Filter[i] = 0.0;
1258 ctx->Convolution2D.Filter[i] = 0.0;
1259 ctx->Separable2D.Filter[i] = 0.0;
1260 }
1261 ASSIGN_4V(ctx->Pixel.PostConvolutionScale, 1.0, 1.0, 1.0, 1.0);
1262 ASSIGN_4V(ctx->Pixel.PostConvolutionBias, 0.0, 0.0, 0.0, 0.0);
1263
1264 /* Point group */
1265 ctx->Point.SmoothFlag = GL_FALSE;
1266 ctx->Point.Size = 1.0;
1267 ctx->Point._Size = 1.0;
1268 ctx->Point.Params[0] = 1.0;
1269 ctx->Point.Params[1] = 0.0;
1270 ctx->Point.Params[2] = 0.0;
1271 ctx->Point._Attenuated = GL_FALSE;
1272 ctx->Point.MinSize = 0.0;
1273 ctx->Point.MaxSize = ctx->Const.MaxPointSize;
1274 ctx->Point.Threshold = 1.0;
1275 ctx->Point.PointSprite = GL_FALSE; /* GL_NV_point_sprite */
1276 ctx->Point.SpriteRMode = GL_ZERO; /* GL_NV_point_sprite */
1277 for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1278 ctx->Point.CoordReplace[i] = GL_FALSE; /* GL_NV_point_sprite */
1279 }
1280
1281 /* Polygon group */
1282 ctx->Polygon.CullFlag = GL_FALSE;
1283 ctx->Polygon.CullFaceMode = GL_BACK;
1284 ctx->Polygon.FrontFace = GL_CCW;
1285 ctx->Polygon._FrontBit = 0;
1286 ctx->Polygon.FrontMode = GL_FILL;
1287 ctx->Polygon.BackMode = GL_FILL;
1288 ctx->Polygon.SmoothFlag = GL_FALSE;
1289 ctx->Polygon.StippleFlag = GL_FALSE;
1290 ctx->Polygon.OffsetFactor = 0.0F;
1291 ctx->Polygon.OffsetUnits = 0.0F;
1292 ctx->Polygon.OffsetPoint = GL_FALSE;
1293 ctx->Polygon.OffsetLine = GL_FALSE;
1294 ctx->Polygon.OffsetFill = GL_FALSE;
1295
1296 /* Polygon Stipple group */
1297 MEMSET( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) );
1298
1299 /* Scissor group */
1300 ctx->Scissor.Enabled = GL_FALSE;
1301 ctx->Scissor.X = 0;
1302 ctx->Scissor.Y = 0;
1303 ctx->Scissor.Width = 0;
1304 ctx->Scissor.Height = 0;
1305
1306 /* Stencil group */
1307 ctx->Stencil.Enabled = GL_FALSE;
1308 ctx->Stencil.TestTwoSide = GL_FALSE;
1309 ctx->Stencil.ActiveFace = 0; /* 0 = GL_FRONT, 1 = GL_BACK */
1310 ctx->Stencil.Function[0] = GL_ALWAYS;
1311 ctx->Stencil.Function[1] = GL_ALWAYS;
1312 ctx->Stencil.FailFunc[0] = GL_KEEP;
1313 ctx->Stencil.FailFunc[1] = GL_KEEP;
1314 ctx->Stencil.ZPassFunc[0] = GL_KEEP;
1315 ctx->Stencil.ZPassFunc[1] = GL_KEEP;
1316 ctx->Stencil.ZFailFunc[0] = GL_KEEP;
1317 ctx->Stencil.ZFailFunc[1] = GL_KEEP;
1318 ctx->Stencil.Ref[0] = 0;
1319 ctx->Stencil.Ref[1] = 0;
1320 ctx->Stencil.ValueMask[0] = STENCIL_MAX;
1321 ctx->Stencil.ValueMask[1] = STENCIL_MAX;
1322 ctx->Stencil.WriteMask[0] = STENCIL_MAX;
1323 ctx->Stencil.WriteMask[1] = STENCIL_MAX;
1324 ctx->Stencil.Clear = 0;
1325
1326 /* Texture group */
1327 ctx->Texture.CurrentUnit = 0; /* multitexture */
1328 ctx->Texture._EnabledUnits = 0;
1329 for (i=0; i<MAX_TEXTURE_UNITS; i++)
1330 init_texture_unit( ctx, i );
1331 ctx->Texture.SharedPalette = GL_FALSE;
1332 _mesa_init_colortable(&ctx->Texture.Palette);
1333
1334 /* Transformation group */
1335 ctx->Transform.MatrixMode = GL_MODELVIEW;
1336 ctx->Transform.Normalize = GL_FALSE;
1337 ctx->Transform.RescaleNormals = GL_FALSE;
1338 ctx->Transform.RasterPositionUnclipped = GL_FALSE;
1339 for (i=0;i<MAX_CLIP_PLANES;i++) {
1340 ASSIGN_4V( ctx->Transform.EyeUserPlane[i], 0.0, 0.0, 0.0, 0.0 );
1341 }
1342 ctx->Transform.ClipPlanesEnabled = 0;
1343
1344 /* Viewport group */
1345 ctx->Viewport.X = 0;
1346 ctx->Viewport.Y = 0;
1347 ctx->Viewport.Width = 0;
1348 ctx->Viewport.Height = 0;
1349 ctx->Viewport.Near = 0.0;
1350 ctx->Viewport.Far = 1.0;
1351 _math_matrix_ctr(&ctx->Viewport._WindowMap);
1352
1353 #define Sz 10
1354 #define Tz 14
1355 ctx->Viewport._WindowMap.m[Sz] = 0.5F * ctx->DepthMaxF;
1356 ctx->Viewport._WindowMap.m[Tz] = 0.5F * ctx->DepthMaxF;
1357 #undef Sz
1358 #undef Tz
1359
1360 ctx->Viewport._WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
1361 ctx->Viewport._WindowMap.type = MATRIX_3D_NO_ROT;
1362
1363 /* Vertex arrays */
1364 ctx->Array.Vertex.Size = 4;
1365 ctx->Array.Vertex.Type = GL_FLOAT;
1366 ctx->Array.Vertex.Stride = 0;
1367 ctx->Array.Vertex.StrideB = 0;
1368 ctx->Array.Vertex.Ptr = NULL;
1369 ctx->Array.Vertex.Enabled = GL_FALSE;
1370 ctx->Array.Vertex.Flags = CA_CLIENT_DATA;
1371 ctx->Array.Normal.Type = GL_FLOAT;
1372 ctx->Array.Normal.Stride = 0;
1373 ctx->Array.Normal.StrideB = 0;
1374 ctx->Array.Normal.Ptr = NULL;
1375 ctx->Array.Normal.Enabled = GL_FALSE;
1376 ctx->Array.Normal.Flags = CA_CLIENT_DATA;
1377 ctx->Array.Color.Size = 4;
1378 ctx->Array.Color.Type = GL_FLOAT;
1379 ctx->Array.Color.Stride = 0;
1380 ctx->Array.Color.StrideB = 0;
1381 ctx->Array.Color.Ptr = NULL;
1382 ctx->Array.Color.Enabled = GL_FALSE;
1383 ctx->Array.Color.Flags = CA_CLIENT_DATA;
1384 ctx->Array.SecondaryColor.Size = 4;
1385 ctx->Array.SecondaryColor.Type = GL_FLOAT;
1386 ctx->Array.SecondaryColor.Stride = 0;
1387 ctx->Array.SecondaryColor.StrideB = 0;
1388 ctx->Array.SecondaryColor.Ptr = NULL;
1389 ctx->Array.SecondaryColor.Enabled = GL_FALSE;
1390 ctx->Array.SecondaryColor.Flags = CA_CLIENT_DATA;
1391 ctx->Array.FogCoord.Size = 1;
1392 ctx->Array.FogCoord.Type = GL_FLOAT;
1393 ctx->Array.FogCoord.Stride = 0;
1394 ctx->Array.FogCoord.StrideB = 0;
1395 ctx->Array.FogCoord.Ptr = NULL;
1396 ctx->Array.FogCoord.Enabled = GL_FALSE;
1397 ctx->Array.FogCoord.Flags = CA_CLIENT_DATA;
1398 ctx->Array.Index.Type = GL_FLOAT;
1399 ctx->Array.Index.Stride = 0;
1400 ctx->Array.Index.StrideB = 0;
1401 ctx->Array.Index.Ptr = NULL;
1402 ctx->Array.Index.Enabled = GL_FALSE;
1403 ctx->Array.Index.Flags = CA_CLIENT_DATA;
1404 for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1405 ctx->Array.TexCoord[i].Size = 4;
1406 ctx->Array.TexCoord[i].Type = GL_FLOAT;
1407 ctx->Array.TexCoord[i].Stride = 0;
1408 ctx->Array.TexCoord[i].StrideB = 0;
1409 ctx->Array.TexCoord[i].Ptr = NULL;
1410 ctx->Array.TexCoord[i].Enabled = GL_FALSE;
1411 ctx->Array.TexCoord[i].Flags = CA_CLIENT_DATA;
1412 }
1413 ctx->Array.TexCoordInterleaveFactor = 1;
1414 ctx->Array.EdgeFlag.Stride = 0;
1415 ctx->Array.EdgeFlag.StrideB = 0;
1416 ctx->Array.EdgeFlag.Ptr = NULL;
1417 ctx->Array.EdgeFlag.Enabled = GL_FALSE;
1418 ctx->Array.EdgeFlag.Flags = CA_CLIENT_DATA;
1419 ctx->Array.ActiveTexture = 0; /* GL_ARB_multitexture */
1420
1421 /* Pixel transfer */
1422 ctx->Pack.Alignment = 4;
1423 ctx->Pack.RowLength = 0;
1424 ctx->Pack.ImageHeight = 0;
1425 ctx->Pack.SkipPixels = 0;
1426 ctx->Pack.SkipRows = 0;
1427 ctx->Pack.SkipImages = 0;
1428 ctx->Pack.SwapBytes = GL_FALSE;
1429 ctx->Pack.LsbFirst = GL_FALSE;
1430 ctx->Unpack.Alignment = 4;
1431 ctx->Unpack.RowLength = 0;
1432 ctx->Unpack.ImageHeight = 0;
1433 ctx->Unpack.SkipPixels = 0;
1434 ctx->Unpack.SkipRows = 0;
1435 ctx->Unpack.SkipImages = 0;
1436 ctx->Unpack.SwapBytes = GL_FALSE;
1437 ctx->Unpack.LsbFirst = GL_FALSE;
1438
1439 /* Feedback */
1440 ctx->Feedback.Type = GL_2D; /* TODO: verify */
1441 ctx->Feedback.Buffer = NULL;
1442 ctx->Feedback.BufferSize = 0;
1443 ctx->Feedback.Count = 0;
1444
1445 /* Selection/picking */
1446 ctx->Select.Buffer = NULL;
1447 ctx->Select.BufferSize = 0;
1448 ctx->Select.BufferCount = 0;
1449 ctx->Select.Hits = 0;
1450 ctx->Select.NameStackDepth = 0;
1451
1452 /* Renderer and client attribute stacks */
1453 ctx->AttribStackDepth = 0;
1454 ctx->ClientAttribStackDepth = 0;
1455
1456 /* Display list */
1457 ctx->CallDepth = 0;
1458 ctx->ExecuteFlag = GL_TRUE;
1459 ctx->CompileFlag = GL_FALSE;
1460 ctx->CurrentListPtr = NULL;
1461 ctx->CurrentBlock = NULL;
1462 ctx->CurrentListNum = 0;
1463 ctx->CurrentPos = 0;
1464
1465 /* Color tables */
1466 _mesa_init_colortable(&ctx->ColorTable);
1467 _mesa_init_colortable(&ctx->ProxyColorTable);
1468 _mesa_init_colortable(&ctx->PostConvolutionColorTable);
1469 _mesa_init_colortable(&ctx->ProxyPostConvolutionColorTable);
1470 _mesa_init_colortable(&ctx->PostColorMatrixColorTable);
1471 _mesa_init_colortable(&ctx->ProxyPostColorMatrixColorTable);
1472
1473 /* GL_NV_vertex_program */
1474 ctx->VertexProgram.Enabled = GL_FALSE;
1475 ctx->VertexProgram.PointSizeEnabled = GL_FALSE;
1476 ctx->VertexProgram.TwoSideEnabled = GL_FALSE;
1477 ctx->VertexProgram.CurrentID = 0;
1478 ctx->VertexProgram.ErrorPos = -1;
1479 ctx->VertexProgram.Current = NULL;
1480 for (i = 0; i < VP_NUM_PROG_REGS / 4; i++) {
1481 ctx->VertexProgram.TrackMatrix[i] = GL_NONE;
1482 ctx->VertexProgram.TrackMatrixTransform[i] = GL_IDENTITY_NV;
1483 }
1484
1485 /* Miscellaneous */
1486 ctx->NewState = _NEW_ALL;
1487 ctx->RenderMode = GL_RENDER;
1488 ctx->_ImageTransferState = 0;
1489
1490 ctx->_NeedNormals = 0;
1491 ctx->_NeedEyeCoords = 0;
1492 ctx->_ModelViewInvScale = 1.0;
1493
1494 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1495
1496 ctx->CatchSignals = GL_TRUE;
1497 ctx->OcclusionResult = GL_FALSE;
1498 ctx->OcclusionResultSaved = GL_FALSE;
1499 ctx->_Facing = 0;
1500
1501 /* For debug/development only */
1502 ctx->NoRaster = ctx->imports.getenv(ctx, "MESA_NO_RASTER") ? GL_TRUE : GL_FALSE;
1503 ctx->FirstTimeCurrent = GL_TRUE;
1504
1505 /* Dither disable */
1506 ctx->NoDither = ctx->imports.getenv(ctx, "MESA_NO_DITHER") ? GL_TRUE : GL_FALSE;
1507 if (ctx->NoDither) {
1508 if (ctx->imports.getenv(ctx, "MESA_DEBUG")) {
1509 _mesa_debug(ctx, "MESA_NO_DITHER set - dithering disabled\n");
1510 }
1511 ctx->Color.DitherFlag = GL_FALSE;
1512 }
1513 }
1514
1515
1516
1517
1518 /*
1519 * Allocate the proxy textures. If we run out of memory part way through
1520 * the allocations clean up and return GL_FALSE.
1521 * Return: GL_TRUE=success, GL_FALSE=failure
1522 */
1523 static GLboolean
1524 alloc_proxy_textures( GLcontext *ctx )
1525 {
1526 GLboolean out_of_memory;
1527 GLint i;
1528
1529 ctx->Texture.Proxy1D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_1D);
1530 if (!ctx->Texture.Proxy1D) {
1531 return GL_FALSE;
1532 }
1533
1534 ctx->Texture.Proxy2D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_2D);
1535 if (!ctx->Texture.Proxy2D) {
1536 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1537 return GL_FALSE;
1538 }
1539
1540 ctx->Texture.Proxy3D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_3D);
1541 if (!ctx->Texture.Proxy3D) {
1542 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1543 _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
1544 return GL_FALSE;
1545 }
1546
1547 ctx->Texture.ProxyCubeMap = _mesa_alloc_texture_object(NULL, 0,
1548 GL_TEXTURE_CUBE_MAP_ARB);
1549 if (!ctx->Texture.ProxyCubeMap) {
1550 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1551 _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
1552 _mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
1553 return GL_FALSE;
1554 }
1555
1556 ctx->Texture.ProxyRect = _mesa_alloc_texture_object(NULL, 0,
1557 GL_TEXTURE_RECTANGLE_NV);
1558 if (!ctx->Texture.ProxyRect) {
1559 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1560 _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
1561 _mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
1562 _mesa_free_texture_object(NULL, ctx->Texture.ProxyCubeMap);
1563 return GL_FALSE;
1564 }
1565
1566 out_of_memory = GL_FALSE;
1567 for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1568 ctx->Texture.Proxy1D->Image[i] = _mesa_alloc_texture_image();
1569 ctx->Texture.Proxy2D->Image[i] = _mesa_alloc_texture_image();
1570 ctx->Texture.Proxy3D->Image[i] = _mesa_alloc_texture_image();
1571 ctx->Texture.ProxyCubeMap->Image[i] = _mesa_alloc_texture_image();
1572 if (!ctx->Texture.Proxy1D->Image[i]
1573 || !ctx->Texture.Proxy2D->Image[i]
1574 || !ctx->Texture.Proxy3D->Image[i]
1575 || !ctx->Texture.ProxyCubeMap->Image[i]) {
1576 out_of_memory = GL_TRUE;
1577 }
1578 }
1579 ctx->Texture.ProxyRect->Image[0] = _mesa_alloc_texture_image();
1580 if (!ctx->Texture.ProxyRect->Image[0])
1581 out_of_memory = GL_TRUE;
1582
1583 if (out_of_memory) {
1584 for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1585 if (ctx->Texture.Proxy1D->Image[i]) {
1586 _mesa_free_texture_image(ctx->Texture.Proxy1D->Image[i]);
1587 }
1588 if (ctx->Texture.Proxy2D->Image[i]) {
1589 _mesa_free_texture_image(ctx->Texture.Proxy2D->Image[i]);
1590 }
1591 if (ctx->Texture.Proxy3D->Image[i]) {
1592 _mesa_free_texture_image(ctx->Texture.Proxy3D->Image[i]);
1593 }
1594 if (ctx->Texture.ProxyCubeMap->Image[i]) {
1595 _mesa_free_texture_image(ctx->Texture.ProxyCubeMap->Image[i]);
1596 }
1597 }
1598 if (ctx->Texture.ProxyRect->Image[0]) {
1599 _mesa_free_texture_image(ctx->Texture.ProxyRect->Image[0]);
1600 }
1601 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1602 _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
1603 _mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
1604 _mesa_free_texture_object(NULL, ctx->Texture.ProxyCubeMap);
1605 _mesa_free_texture_object(NULL, ctx->Texture.ProxyRect);
1606 return GL_FALSE;
1607 }
1608 else {
1609 return GL_TRUE;
1610 }
1611 }
1612
1613
1614 static void add_debug_flags( const char *debug )
1615 {
1616 #ifdef MESA_DEBUG
1617 if (strstr(debug, "varray"))
1618 MESA_VERBOSE |= VERBOSE_VARRAY;
1619
1620 if (strstr(debug, "tex"))
1621 MESA_VERBOSE |= VERBOSE_TEXTURE;
1622
1623 if (strstr(debug, "imm"))
1624 MESA_VERBOSE |= VERBOSE_IMMEDIATE;
1625
1626 if (strstr(debug, "pipe"))
1627 MESA_VERBOSE |= VERBOSE_PIPELINE;
1628
1629 if (strstr(debug, "driver"))
1630 MESA_VERBOSE |= VERBOSE_DRIVER;
1631
1632 if (strstr(debug, "state"))
1633 MESA_VERBOSE |= VERBOSE_STATE;
1634
1635 if (strstr(debug, "api"))
1636 MESA_VERBOSE |= VERBOSE_API;
1637
1638 if (strstr(debug, "list"))
1639 MESA_VERBOSE |= VERBOSE_DISPLAY_LIST;
1640
1641 if (strstr(debug, "lighting"))
1642 MESA_VERBOSE |= VERBOSE_LIGHTING;
1643
1644 /* Debug flag:
1645 */
1646 if (strstr(debug, "flush"))
1647 MESA_DEBUG_FLAGS |= DEBUG_ALWAYS_FLUSH;
1648 #endif
1649 }
1650
1651
1652 /*
1653 * Initialize a GLcontext struct. This includes allocating all the
1654 * other structs and arrays which hang off of the context by pointers.
1655 */
1656 GLboolean
1657 _mesa_initialize_context( GLcontext *ctx,
1658 const GLvisual *visual,
1659 GLcontext *share_list,
1660 const __GLimports *imports )
1661 {
1662 GLuint dispatchSize;
1663
1664 ASSERT(imports);
1665 ASSERT(imports->other); /* other points to the device driver's context */
1666
1667 /* assing imports */
1668 ctx->imports = *imports;
1669
1670 /* initialize the exports (Mesa functions called by the window system) */
1671 _mesa_init_default_exports( &(ctx->exports) );
1672
1673 /* misc one-time initializations */
1674 one_time_init(ctx);
1675
1676 #if 0
1677 /**
1678 ** OpenGL SI stuff
1679 **/
1680 if (!ctx->imports.malloc) {
1681 _mesa_init_default_imports(&ctx->imports, driver_ctx);
1682 }
1683 /* exports are setup by the device driver */
1684 #endif
1685
1686 ctx->DriverCtx = imports->other;
1687 ctx->Visual = *visual;
1688 ctx->DrawBuffer = NULL;
1689 ctx->ReadBuffer = NULL;
1690
1691 if (share_list) {
1692 /* share state with another context */
1693 ctx->Shared = share_list->Shared;
1694 }
1695 else {
1696 /* allocate new, unshared state */
1697 ctx->Shared = alloc_shared_state();
1698 if (!ctx->Shared) {
1699 return GL_FALSE;
1700 }
1701 }
1702 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1703 ctx->Shared->RefCount++;
1704 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1705
1706 /* Effectively bind the default textures to all texture units */
1707 ctx->Shared->Default1D->RefCount += MAX_TEXTURE_UNITS;
1708 ctx->Shared->Default2D->RefCount += MAX_TEXTURE_UNITS;
1709 ctx->Shared->Default3D->RefCount += MAX_TEXTURE_UNITS;
1710 ctx->Shared->DefaultCubeMap->RefCount += MAX_TEXTURE_UNITS;
1711 ctx->Shared->DefaultRect->RefCount += MAX_TEXTURE_UNITS;
1712
1713 init_attrib_groups( ctx );
1714
1715 if (visual->doubleBufferMode) {
1716 ctx->Color.DrawBuffer = GL_BACK;
1717 ctx->Color._DriverDrawBuffer = GL_BACK_LEFT;
1718 ctx->Color._DrawDestMask = BACK_LEFT_BIT;
1719 ctx->Pixel.ReadBuffer = GL_BACK;
1720 ctx->Pixel._DriverReadBuffer = GL_BACK_LEFT;
1721 }
1722 else {
1723 ctx->Color.DrawBuffer = GL_FRONT;
1724 ctx->Color._DriverDrawBuffer = GL_FRONT_LEFT;
1725 ctx->Color._DrawDestMask = FRONT_LEFT_BIT;
1726 ctx->Pixel.ReadBuffer = GL_FRONT;
1727 ctx->Pixel._DriverReadBuffer = GL_FRONT_LEFT;
1728 }
1729
1730 if (!alloc_proxy_textures(ctx)) {
1731 free_shared_state(ctx, ctx->Shared);
1732 return GL_FALSE;
1733 }
1734
1735 /* register the most recent extension functions with libGL */
1736 _glapi_add_entrypoint("glTbufferMask3DFX", 553);
1737 _glapi_add_entrypoint("glCompressedTexImage3DARB", 554);
1738 _glapi_add_entrypoint("glCompressedTexImage2DARB", 555);
1739 _glapi_add_entrypoint("glCompressedTexImage1DARB", 556);
1740 _glapi_add_entrypoint("glCompressedTexSubImage3DARB", 557);
1741 _glapi_add_entrypoint("glCompressedTexSubImage2DARB", 558);
1742 _glapi_add_entrypoint("glCompressedTexSubImage1DARB", 559);
1743 _glapi_add_entrypoint("glGetCompressedTexImageARB", 560);
1744 /* XXX we should add a bunch of new functions here */
1745
1746
1747 /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1748 * In practice, this'll be the same for stand-alone Mesa. But for DRI
1749 * Mesa we do this to accomodate different versions of libGL and various
1750 * DRI drivers.
1751 */
1752 dispatchSize = MAX2(_glapi_get_dispatch_table_size(),
1753 sizeof(struct _glapi_table) / sizeof(void *));
1754
1755 /* setup API dispatch tables */
1756 ctx->Exec = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
1757 ctx->Save = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
1758 if (!ctx->Exec || !ctx->Save) {
1759 free_shared_state(ctx, ctx->Shared);
1760 if (ctx->Exec)
1761 FREE( ctx->Exec );
1762 }
1763 _mesa_init_exec_table(ctx->Exec, dispatchSize);
1764 _mesa_init_dlist_table(ctx->Save, dispatchSize);
1765 ctx->CurrentDispatch = ctx->Exec;
1766
1767 ctx->ExecPrefersFloat = GL_FALSE;
1768 ctx->SavePrefersFloat = GL_FALSE;
1769
1770 /* Neutral tnl module stuff */
1771 _mesa_init_exec_vtxfmt( ctx );
1772 ctx->TnlModule.Current = NULL;
1773 ctx->TnlModule.SwapCount = 0;
1774
1775 /* Z buffer stuff */
1776 if (ctx->Visual.depthBits == 0) {
1777 /* Special case. Even if we don't have a depth buffer we need
1778 * good values for DepthMax for Z vertex transformation purposes
1779 * and for per-fragment fog computation.
1780 */
1781 ctx->DepthMax = 1 << 16;
1782 ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
1783 }
1784 else if (ctx->Visual.depthBits < 32) {
1785 ctx->DepthMax = (1 << ctx->Visual.depthBits) - 1;
1786 ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
1787 }
1788 else {
1789 /* Special case since shift values greater than or equal to the
1790 * number of bits in the left hand expression's type are undefined.
1791 */
1792 ctx->DepthMax = 0xffffffff;
1793 ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
1794 }
1795 ctx->MRD = 1.0; /* Minimum resolvable depth value, for polygon offset */
1796
1797
1798 #if defined(MESA_TRACE)
1799 ctx->TraceCtx = (trace_context_t *) CALLOC( sizeof(trace_context_t) );
1800 #if 0
1801 /* Brian: do you want to have CreateContext fail here,
1802 or should we just trap in NewTrace (currently done)? */
1803 if (!(ctx->TraceCtx)) {
1804 free_shared_state(ctx, ctx->Shared);
1805 FREE( ctx->Exec );
1806 FREE( ctx->Save );
1807 return GL_FALSE;
1808 }
1809 #endif
1810 trInitContext(ctx->TraceCtx);
1811
1812 ctx->TraceDispatch = (struct _glapi_table *)
1813 CALLOC(dispatchSize * sizeof(void*));
1814 #if 0
1815 if (!(ctx->TraceCtx)) {
1816 free_shared_state(ctx, ctx->Shared);
1817 FREE( ctx->Exec );
1818 FREE( ctx->Save );
1819 FREE( ctx->TraceCtx );
1820 return GL_FALSE;
1821 }
1822 #endif
1823 trInitDispatch(ctx->TraceDispatch);
1824 #endif
1825
1826
1827 if (ctx->imports.getenv(ctx, "MESA_DEBUG"))
1828 add_debug_flags(ctx->imports.getenv(ctx, "MESA_DEBUG"));
1829
1830 if (ctx->imports.getenv(ctx, "MESA_VERBOSE"))
1831 add_debug_flags(ctx->imports.getenv(ctx, "MESA_VERBOSE"));
1832
1833 return GL_TRUE;
1834 }
1835
1836
1837
1838 /*
1839 * Allocate and initialize a GLcontext structure.
1840 * Input: visual - a GLvisual pointer (we copy the struct contents)
1841 * sharelist - another context to share display lists with or NULL
1842 * imports - points to a fully-initialized __GLimports object.
1843 * Return: pointer to a new __GLcontextRec or NULL if error.
1844 */
1845 GLcontext *
1846 _mesa_create_context( const GLvisual *visual,
1847 GLcontext *share_list,
1848 const __GLimports *imports )
1849 {
1850 GLcontext *ctx;
1851
1852 ASSERT(visual);
1853 ASSERT(imports);
1854 ASSERT(imports->calloc);
1855
1856 ctx = (GLcontext *) imports->calloc(NULL, 1, sizeof(GLcontext));
1857 if (!ctx)
1858 return NULL;
1859
1860 ctx->Driver.CurrentExecPrimitive = 0; /* XXX why is this here??? */
1861
1862 if (_mesa_initialize_context(ctx, visual, share_list, imports)) {
1863 return ctx;
1864 }
1865 else {
1866 imports->free(NULL, ctx);
1867 return NULL;
1868 }
1869 }
1870
1871
1872
1873 /*
1874 * Free the data associated with the given context.
1875 * But don't free() the GLcontext struct itself!
1876 */
1877 void
1878 _mesa_free_context_data( GLcontext *ctx )
1879 {
1880 struct gl_shine_tab *s, *tmps;
1881 GLuint i;
1882
1883 /* if we're destroying the current context, unbind it first */
1884 if (ctx == _mesa_get_current_context()) {
1885 _mesa_make_current(NULL, NULL);
1886 }
1887
1888 /*
1889 * Free transformation matrix stacks
1890 */
1891 free_matrix_stack(&ctx->ModelviewMatrixStack);
1892 free_matrix_stack(&ctx->ProjectionMatrixStack);
1893 free_matrix_stack(&ctx->ColorMatrixStack);
1894 for (i = 0; i < MAX_TEXTURE_UNITS; i++)
1895 free_matrix_stack(&ctx->TextureMatrixStack[i]);
1896 for (i = 0; i < MAX_PROGRAM_MATRICES; i++)
1897 free_matrix_stack(&ctx->ProgramMatrixStack[i]);
1898 /* combined Modelview*Projection matrix */
1899 _math_matrix_dtr( &ctx->_ModelProjectMatrix );
1900
1901
1902 if (ctx->VertexProgram.Current) {
1903 ctx->VertexProgram.Current->RefCount--;
1904 if (ctx->VertexProgram.Current->RefCount <= 0)
1905 _mesa_delete_program(ctx, ctx->VertexProgram.CurrentID);
1906 }
1907
1908 /* Shared context state (display lists, textures, etc) */
1909 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1910 ctx->Shared->RefCount--;
1911 assert(ctx->Shared->RefCount >= 0);
1912 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1913 if (ctx->Shared->RefCount == 0) {
1914 /* free shared state */
1915 free_shared_state( ctx, ctx->Shared );
1916 }
1917
1918 /* Free lighting shininess exponentiation table */
1919 foreach_s( s, tmps, ctx->_ShineTabList ) {
1920 FREE( s );
1921 }
1922 FREE( ctx->_ShineTabList );
1923
1924 /* Free proxy texture objects */
1925 _mesa_free_texture_object( NULL, ctx->Texture.Proxy1D );
1926 _mesa_free_texture_object( NULL, ctx->Texture.Proxy2D );
1927 _mesa_free_texture_object( NULL, ctx->Texture.Proxy3D );
1928 _mesa_free_texture_object( NULL, ctx->Texture.ProxyCubeMap );
1929 _mesa_free_texture_object( NULL, ctx->Texture.ProxyRect );
1930
1931 /* Free evaluator data */
1932 if (ctx->EvalMap.Map1Vertex3.Points)
1933 FREE( ctx->EvalMap.Map1Vertex3.Points );
1934 if (ctx->EvalMap.Map1Vertex4.Points)
1935 FREE( ctx->EvalMap.Map1Vertex4.Points );
1936 if (ctx->EvalMap.Map1Index.Points)
1937 FREE( ctx->EvalMap.Map1Index.Points );
1938 if (ctx->EvalMap.Map1Color4.Points)
1939 FREE( ctx->EvalMap.Map1Color4.Points );
1940 if (ctx->EvalMap.Map1Normal.Points)
1941 FREE( ctx->EvalMap.Map1Normal.Points );
1942 if (ctx->EvalMap.Map1Texture1.Points)
1943 FREE( ctx->EvalMap.Map1Texture1.Points );
1944 if (ctx->EvalMap.Map1Texture2.Points)
1945 FREE( ctx->EvalMap.Map1Texture2.Points );
1946 if (ctx->EvalMap.Map1Texture3.Points)
1947 FREE( ctx->EvalMap.Map1Texture3.Points );
1948 if (ctx->EvalMap.Map1Texture4.Points)
1949 FREE( ctx->EvalMap.Map1Texture4.Points );
1950 for (i = 0; i < 16; i++)
1951 FREE((ctx->EvalMap.Map1Attrib[i].Points));
1952
1953 if (ctx->EvalMap.Map2Vertex3.Points)
1954 FREE( ctx->EvalMap.Map2Vertex3.Points );
1955 if (ctx->EvalMap.Map2Vertex4.Points)
1956 FREE( ctx->EvalMap.Map2Vertex4.Points );
1957 if (ctx->EvalMap.Map2Index.Points)
1958 FREE( ctx->EvalMap.Map2Index.Points );
1959 if (ctx->EvalMap.Map2Color4.Points)
1960 FREE( ctx->EvalMap.Map2Color4.Points );
1961 if (ctx->EvalMap.Map2Normal.Points)
1962 FREE( ctx->EvalMap.Map2Normal.Points );
1963 if (ctx->EvalMap.Map2Texture1.Points)
1964 FREE( ctx->EvalMap.Map2Texture1.Points );
1965 if (ctx->EvalMap.Map2Texture2.Points)
1966 FREE( ctx->EvalMap.Map2Texture2.Points );
1967 if (ctx->EvalMap.Map2Texture3.Points)
1968 FREE( ctx->EvalMap.Map2Texture3.Points );
1969 if (ctx->EvalMap.Map2Texture4.Points)
1970 FREE( ctx->EvalMap.Map2Texture4.Points );
1971 for (i = 0; i < 16; i++)
1972 FREE((ctx->EvalMap.Map2Attrib[i].Points));
1973
1974 _mesa_free_colortable_data( &ctx->ColorTable );
1975 _mesa_free_colortable_data( &ctx->PostConvolutionColorTable );
1976 _mesa_free_colortable_data( &ctx->PostColorMatrixColorTable );
1977 _mesa_free_colortable_data( &ctx->Texture.Palette );
1978
1979 _math_matrix_dtr(&ctx->Viewport._WindowMap);
1980
1981 _mesa_extensions_dtr(ctx);
1982
1983 FREE(ctx->Exec);
1984 FREE(ctx->Save);
1985 }
1986
1987
1988
1989 /*
1990 * Destroy a GLcontext structure.
1991 */
1992 void
1993 _mesa_destroy_context( GLcontext *ctx )
1994 {
1995 if (ctx) {
1996 _mesa_free_context_data(ctx);
1997 FREE( (void *) ctx );
1998 }
1999 }
2000
2001
2002
2003 /*
2004 * Copy attribute groups from one context to another.
2005 * Input: src - source context
2006 * dst - destination context
2007 * mask - bitwise OR of GL_*_BIT flags
2008 */
2009 void
2010 _mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
2011 {
2012 if (mask & GL_ACCUM_BUFFER_BIT) {
2013 /* OK to memcpy */
2014 dst->Accum = src->Accum;
2015 }
2016 if (mask & GL_COLOR_BUFFER_BIT) {
2017 /* OK to memcpy */
2018 dst->Color = src->Color;
2019 }
2020 if (mask & GL_CURRENT_BIT) {
2021 /* OK to memcpy */
2022 dst->Current = src->Current;
2023 }
2024 if (mask & GL_DEPTH_BUFFER_BIT) {
2025 /* OK to memcpy */
2026 dst->Depth = src->Depth;
2027 }
2028 if (mask & GL_ENABLE_BIT) {
2029 /* no op */
2030 }
2031 if (mask & GL_EVAL_BIT) {
2032 /* OK to memcpy */
2033 dst->Eval = src->Eval;
2034 }
2035 if (mask & GL_FOG_BIT) {
2036 /* OK to memcpy */
2037 dst->Fog = src->Fog;
2038 }
2039 if (mask & GL_HINT_BIT) {
2040 /* OK to memcpy */
2041 dst->Hint = src->Hint;
2042 }
2043 if (mask & GL_LIGHTING_BIT) {
2044 GLuint i;
2045 /* begin with memcpy */
2046 MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light) );
2047 /* fixup linked lists to prevent pointer insanity */
2048 make_empty_list( &(dst->Light.EnabledList) );
2049 for (i = 0; i < MAX_LIGHTS; i++) {
2050 if (dst->Light.Light[i].Enabled) {
2051 insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
2052 }
2053 }
2054 }
2055 if (mask & GL_LINE_BIT) {
2056 /* OK to memcpy */
2057 dst->Line = src->Line;
2058 }
2059 if (mask & GL_LIST_BIT) {
2060 /* OK to memcpy */
2061 dst->List = src->List;
2062 }
2063 if (mask & GL_PIXEL_MODE_BIT) {
2064 /* OK to memcpy */
2065 dst->Pixel = src->Pixel;
2066 }
2067 if (mask & GL_POINT_BIT) {
2068 /* OK to memcpy */
2069 dst->Point = src->Point;
2070 }
2071 if (mask & GL_POLYGON_BIT) {
2072 /* OK to memcpy */
2073 dst->Polygon = src->Polygon;
2074 }
2075 if (mask & GL_POLYGON_STIPPLE_BIT) {
2076 /* Use loop instead of MEMCPY due to problem with Portland Group's
2077 * C compiler. Reported by John Stone.
2078 */
2079 GLuint i;
2080 for (i = 0; i < 32; i++) {
2081 dst->PolygonStipple[i] = src->PolygonStipple[i];
2082 }
2083 }
2084 if (mask & GL_SCISSOR_BIT) {
2085 /* OK to memcpy */
2086 dst->Scissor = src->Scissor;
2087 }
2088 if (mask & GL_STENCIL_BUFFER_BIT) {
2089 /* OK to memcpy */
2090 dst->Stencil = src->Stencil;
2091 }
2092 if (mask & GL_TEXTURE_BIT) {
2093 /* Cannot memcpy because of pointers */
2094 _mesa_copy_texture_state(src, dst);
2095 }
2096 if (mask & GL_TRANSFORM_BIT) {
2097 /* OK to memcpy */
2098 dst->Transform = src->Transform;
2099 }
2100 if (mask & GL_VIEWPORT_BIT) {
2101 /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
2102 dst->Viewport.X = src->Viewport.X;
2103 dst->Viewport.Y = src->Viewport.Y;
2104 dst->Viewport.Width = src->Viewport.Width;
2105 dst->Viewport.Height = src->Viewport.Height;
2106 dst->Viewport.Near = src->Viewport.Near;
2107 dst->Viewport.Far = src->Viewport.Far;
2108 _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
2109 }
2110
2111 /* XXX FIXME: Call callbacks?
2112 */
2113 dst->NewState = _NEW_ALL;
2114 }
2115
2116
2117
2118 static void print_info( void )
2119 {
2120 _mesa_debug(NULL, "Mesa GL_VERSION = %s\n",
2121 (char *) _mesa_GetString(GL_VERSION));
2122 _mesa_debug(NULL, "Mesa GL_RENDERER = %s\n",
2123 (char *) _mesa_GetString(GL_RENDERER));
2124 _mesa_debug(NULL, "Mesa GL_VENDOR = %s\n",
2125 (char *) _mesa_GetString(GL_VENDOR));
2126 _mesa_debug(NULL, "Mesa GL_EXTENSIONS = %s\n",
2127 (char *) _mesa_GetString(GL_EXTENSIONS));
2128 #if defined(THREADS)
2129 _mesa_debug(NULL, "Mesa thread-safe: YES\n");
2130 #else
2131 _mesa_debug(NULL, "Mesa thread-safe: NO\n");
2132 #endif
2133 #if defined(USE_X86_ASM)
2134 _mesa_debug(NULL, "Mesa x86-optimized: YES\n");
2135 #else
2136 _mesa_debug(NULL, "Mesa x86-optimized: NO\n");
2137 #endif
2138 #if defined(USE_SPARC_ASM)
2139 _mesa_debug(NULL, "Mesa sparc-optimized: YES\n");
2140 #else
2141 _mesa_debug(NULL, "Mesa sparc-optimized: NO\n");
2142 #endif
2143 }
2144
2145
2146 /*
2147 * Set the current context, binding the given frame buffer to the context.
2148 */
2149 void
2150 _mesa_make_current( GLcontext *newCtx, GLframebuffer *buffer )
2151 {
2152 _mesa_make_current2( newCtx, buffer, buffer );
2153 }
2154
2155
2156 /*
2157 * Bind the given context to the given draw-buffer and read-buffer
2158 * and make it the current context for this thread.
2159 */
2160 void
2161 _mesa_make_current2( GLcontext *newCtx, GLframebuffer *drawBuffer,
2162 GLframebuffer *readBuffer )
2163 {
2164 if (MESA_VERBOSE)
2165 _mesa_debug(newCtx, "_mesa_make_current2()\n");
2166
2167 /* Check that the context's and framebuffer's visuals are compatible.
2168 * We could do a lot more checking here but this'll catch obvious
2169 * problems.
2170 */
2171 if (newCtx && drawBuffer && readBuffer) {
2172 if (newCtx->Visual.rgbMode != drawBuffer->Visual.rgbMode ||
2173 newCtx->Visual.redBits != drawBuffer->Visual.redBits ||
2174 newCtx->Visual.depthBits != drawBuffer->Visual.depthBits ||
2175 newCtx->Visual.stencilBits != drawBuffer->Visual.stencilBits ||
2176 newCtx->Visual.accumRedBits != drawBuffer->Visual.accumRedBits) {
2177 return; /* incompatible */
2178 }
2179 }
2180
2181 /* We call this function periodically (just here for now) in
2182 * order to detect when multithreading has begun.
2183 */
2184 _glapi_check_multithread();
2185
2186 _glapi_set_context((void *) newCtx);
2187 ASSERT(_mesa_get_current_context() == newCtx);
2188
2189
2190 if (!newCtx) {
2191 _glapi_set_dispatch(NULL); /* none current */
2192 }
2193 else {
2194 _glapi_set_dispatch(newCtx->CurrentDispatch);
2195
2196 if (drawBuffer && readBuffer) {
2197 /* TODO: check if newCtx and buffer's visual match??? */
2198 newCtx->DrawBuffer = drawBuffer;
2199 newCtx->ReadBuffer = readBuffer;
2200 newCtx->NewState |= _NEW_BUFFERS;
2201
2202 if (drawBuffer->Width == 0 && drawBuffer->Height == 0) {
2203 /* get initial window size */
2204 GLuint bufWidth, bufHeight;
2205
2206 /* ask device driver for size of output buffer */
2207 (*newCtx->Driver.GetBufferSize)( drawBuffer, &bufWidth, &bufHeight );
2208
2209 if (drawBuffer->Width == bufWidth && drawBuffer->Height == bufHeight)
2210 return; /* size is as expected */
2211
2212 drawBuffer->Width = bufWidth;
2213 drawBuffer->Height = bufHeight;
2214
2215 newCtx->Driver.ResizeBuffers( drawBuffer );
2216 }
2217
2218 if (readBuffer != drawBuffer &&
2219 readBuffer->Width == 0 && readBuffer->Height == 0) {
2220 /* get initial window size */
2221 GLuint bufWidth, bufHeight;
2222
2223 /* ask device driver for size of output buffer */
2224 (*newCtx->Driver.GetBufferSize)( readBuffer, &bufWidth, &bufHeight );
2225
2226 if (readBuffer->Width == bufWidth && readBuffer->Height == bufHeight)
2227 return; /* size is as expected */
2228
2229 readBuffer->Width = bufWidth;
2230 readBuffer->Height = bufHeight;
2231
2232 newCtx->Driver.ResizeBuffers( readBuffer );
2233 }
2234 }
2235
2236 /* This is only for T&L - a bit out of place, or misnamed (BP) */
2237 if (newCtx->Driver.MakeCurrent)
2238 newCtx->Driver.MakeCurrent( newCtx, drawBuffer, readBuffer );
2239
2240 /* We can use this to help debug user's problems. Tell them to set
2241 * the MESA_INFO env variable before running their app. Then the
2242 * first time each context is made current we'll print some useful
2243 * information.
2244 */
2245 if (newCtx->FirstTimeCurrent) {
2246 if (newCtx->imports.getenv(newCtx, "MESA_INFO")) {
2247 print_info();
2248 }
2249 newCtx->FirstTimeCurrent = GL_FALSE;
2250 }
2251 }
2252 }
2253
2254
2255
2256 /*
2257 * Return current context handle for the calling thread.
2258 * This isn't the fastest way to get the current context.
2259 * If you need speed, see the GET_CURRENT_CONTEXT() macro in context.h
2260 */
2261 GLcontext *
2262 _mesa_get_current_context( void )
2263 {
2264 return (GLcontext *) _glapi_get_context();
2265 }
2266
2267
2268
2269 /*
2270 * This should be called by device drivers just before they do a
2271 * swapbuffers. Any pending rendering commands will be executed.
2272 * XXX we should really rename this function to _mesa_flush() or something.
2273 */
2274 void
2275 _mesa_swapbuffers(GLcontext *ctx)
2276 {
2277 FLUSH_VERTICES( ctx, 0 );
2278 }
2279
2280
2281
2282 /*
2283 * Return pointer to this context's current API dispatch table.
2284 * It'll either be the immediate-mode execute dispatcher or the
2285 * display list compile dispatcher.
2286 */
2287 struct _glapi_table *
2288 _mesa_get_dispatch(GLcontext *ctx)
2289 {
2290 return ctx->CurrentDispatch;
2291 }
2292
2293
2294
2295 /**********************************************************************/
2296 /***** Miscellaneous functions *****/
2297 /**********************************************************************/
2298
2299
2300 /*
2301 * Record the given error code and call the driver's Error function if defined.
2302 * This is called via _mesa_error().
2303 */
2304 void
2305 _mesa_record_error( GLcontext *ctx, GLenum error )
2306 {
2307 if (!ctx)
2308 return;
2309
2310 if (ctx->ErrorValue == GL_NO_ERROR) {
2311 ctx->ErrorValue = error;
2312 }
2313
2314 /* Call device driver's error handler, if any. This is used on the Mac. */
2315 if (ctx->Driver.Error) {
2316 (*ctx->Driver.Error)( ctx );
2317 }
2318 }
2319
2320
2321 void
2322 _mesa_Finish( void )
2323 {
2324 GET_CURRENT_CONTEXT(ctx);
2325 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
2326 if (ctx->Driver.Finish) {
2327 (*ctx->Driver.Finish)( ctx );
2328 }
2329 }
2330
2331
2332
2333 void
2334 _mesa_Flush( void )
2335 {
2336 GET_CURRENT_CONTEXT(ctx);
2337 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
2338 if (ctx->Driver.Flush) {
2339 (*ctx->Driver.Flush)( ctx );
2340 }
2341 }
2342
2343
2344
2345 const char *_mesa_prim_name[GL_POLYGON+4] = {
2346 "GL_POINTS",
2347 "GL_LINES",
2348 "GL_LINE_LOOP",
2349 "GL_LINE_STRIP",
2350 "GL_TRIANGLES",
2351 "GL_TRIANGLE_STRIP",
2352 "GL_TRIANGLE_FAN",
2353 "GL_QUADS",
2354 "GL_QUAD_STRIP",
2355 "GL_POLYGON",
2356 "outside begin/end",
2357 "inside unkown primitive",
2358 "unknown state"
2359 };