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