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