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