projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
new texture compression infrastructure
[mesa.git] / src / mesa / main / context.c
1 /* $Id: context.c,v 1.177 2002/09/27 02:45:37 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 _glapi_set_warning_func( (_glapi_warning_func) _mesa_warning );
583 }
584 else {
585 _glapi_noop_enable_warnings(GL_FALSE);
586 }
587
588 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
589 _mesa_debug(ctx, "Mesa DEBUG build %s %s\n", __DATE__, __TIME__);
590 #endif
591
592 alreadyCalled = GL_TRUE;
593 }
594 _glthread_UNLOCK_MUTEX(OneTimeLock);
595 }
596
597
598 static void
599 init_matrix_stack( struct matrix_stack *stack,
600 GLuint maxDepth, GLuint dirtyFlag )
601 {
602 GLuint i;
603
604 stack->Depth = 0;
605 stack->MaxDepth = maxDepth;
606 stack->DirtyFlag = dirtyFlag;
607 /* The stack */
608 stack->Stack = (GLmatrix *) CALLOC(maxDepth * sizeof(GLmatrix));
609 for (i = 0; i < maxDepth; i++) {
610 _math_matrix_ctr(&stack->Stack[i]);
611 _math_matrix_alloc_inv(&stack->Stack[i]);
612 }
613 stack->Top = stack->Stack;
614 }
615
616
617 static void
618 free_matrix_stack( struct matrix_stack *stack )
619 {
620 GLuint i;
621 for (i = 0; i < stack->MaxDepth; i++) {
622 _math_matrix_dtr(&stack->Stack[i]);
623 }
624 FREE(stack->Stack);
625 stack->Stack = stack->Top = NULL;
626 }
627
628
629 /*
630 * Allocate and initialize a shared context state structure.
631 */
632 static struct gl_shared_state *
633 alloc_shared_state( void )
634 {
635 struct gl_shared_state *ss;
636 GLboolean outOfMemory;
637
638 ss = CALLOC_STRUCT(gl_shared_state);
639 if (!ss)
640 return NULL;
641
642 _glthread_INIT_MUTEX(ss->Mutex);
643
644 ss->DisplayList = _mesa_NewHashTable();
645 ss->TexObjects = _mesa_NewHashTable();
646 ss->VertexPrograms = _mesa_NewHashTable();
647
648 /* Default Texture objects */
649 outOfMemory = GL_FALSE;
650
651 ss->Default1D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_1D);
652 if (!ss->Default1D) {
653 outOfMemory = GL_TRUE;
654 }
655
656 ss->Default2D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_2D);
657 if (!ss->Default2D) {
658 outOfMemory = GL_TRUE;
659 }
660
661 ss->Default3D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_3D);
662 if (!ss->Default3D) {
663 outOfMemory = GL_TRUE;
664 }
665
666 ss->DefaultCubeMap = _mesa_alloc_texture_object(ss, 0,
667 GL_TEXTURE_CUBE_MAP_ARB);
668 if (!ss->DefaultCubeMap) {
669 outOfMemory = GL_TRUE;
670 }
671
672 ss->DefaultRect = _mesa_alloc_texture_object(ss, 0,
673 GL_TEXTURE_RECTANGLE_NV);
674 if (!ss->DefaultRect) {
675 outOfMemory = GL_TRUE;
676 }
677
678 if (!ss->DisplayList || !ss->TexObjects || !ss->VertexPrograms
679 || outOfMemory) {
680 /* Ran out of memory at some point. Free everything and return NULL */
681 if (ss->DisplayList)
682 _mesa_DeleteHashTable(ss->DisplayList);
683 if (ss->TexObjects)
684 _mesa_DeleteHashTable(ss->TexObjects);
685 if (ss->VertexPrograms)
686 _mesa_DeleteHashTable(ss->VertexPrograms);
687 if (ss->Default1D)
688 _mesa_free_texture_object(ss, ss->Default1D);
689 if (ss->Default2D)
690 _mesa_free_texture_object(ss, ss->Default2D);
691 if (ss->Default3D)
692 _mesa_free_texture_object(ss, ss->Default3D);
693 if (ss->DefaultCubeMap)
694 _mesa_free_texture_object(ss, ss->DefaultCubeMap);
695 if (ss->DefaultRect)
696 _mesa_free_texture_object(ss, ss->DefaultRect);
697 FREE(ss);
698 return NULL;
699 }
700 else {
701 return ss;
702 }
703 }
704
705
706 /*
707 * Deallocate a shared state context and all children structures.
708 */
709 static void
710 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
711 {
712 /* Free display lists */
713 while (1) {
714 GLuint list = _mesa_HashFirstEntry(ss->DisplayList);
715 if (list) {
716 _mesa_destroy_list(ctx, list);
717 }
718 else {
719 break;
720 }
721 }
722 _mesa_DeleteHashTable(ss->DisplayList);
723
724 /* Free texture objects */
725 while (ss->TexObjectList) {
726 if (ctx->Driver.DeleteTexture)
727 (*ctx->Driver.DeleteTexture)( ctx, ss->TexObjectList );
728 /* this function removes from linked list too! */
729 _mesa_free_texture_object(ss, ss->TexObjectList);
730 }
731 _mesa_DeleteHashTable(ss->TexObjects);
732
733 /* Free vertex programs */
734 while (1) {
735 GLuint prog = _mesa_HashFirstEntry(ss->VertexPrograms);
736 if (prog) {
737 _mesa_delete_program(ctx, prog);
738 }
739 else {
740 break;
741 }
742 }
743 _mesa_DeleteHashTable(ss->VertexPrograms);
744
745 FREE(ss);
746 }
747
748
749
750 /*
751 * Initialize the nth light. Note that the defaults for light 0 are
752 * different than the other lights.
753 */
754 static void
755 init_light( struct gl_light *l, GLuint n )
756 {
757 make_empty_list( l );
758
759 ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 );
760 if (n==0) {
761 ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 );
762 ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 );
763 }
764 else {
765 ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 );
766 ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 );
767 }
768 ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 );
769 ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 );
770 l->SpotExponent = 0.0;
771 _mesa_invalidate_spot_exp_table( l );
772 l->SpotCutoff = 180.0;
773 l->_CosCutoff = 0.0; /* KW: -ve values not admitted */
774 l->ConstantAttenuation = 1.0;
775 l->LinearAttenuation = 0.0;
776 l->QuadraticAttenuation = 0.0;
777 l->Enabled = GL_FALSE;
778 }
779
780
781
782 static void
783 init_lightmodel( struct gl_lightmodel *lm )
784 {
785 ASSIGN_4V( lm->Ambient, 0.2F, 0.2F, 0.2F, 1.0F );
786 lm->LocalViewer = GL_FALSE;
787 lm->TwoSide = GL_FALSE;
788 lm->ColorControl = GL_SINGLE_COLOR;
789 }
790
791
792 static void
793 init_material( struct gl_material *m )
794 {
795 ASSIGN_4V( m->Ambient, 0.2F, 0.2F, 0.2F, 1.0F );
796 ASSIGN_4V( m->Diffuse, 0.8F, 0.8F, 0.8F, 1.0F );
797 ASSIGN_4V( m->Specular, 0.0F, 0.0F, 0.0F, 1.0F );
798 ASSIGN_4V( m->Emission, 0.0F, 0.0F, 0.0F, 1.0F );
799 m->Shininess = 0.0;
800 m->AmbientIndex = 0;
801 m->DiffuseIndex = 1;
802 m->SpecularIndex = 1;
803 }
804
805
806
807 static void
808 init_texture_unit( GLcontext *ctx, GLuint unit )
809 {
810 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
811
812 texUnit->EnvMode = GL_MODULATE;
813 texUnit->CombineModeRGB = GL_MODULATE;
814 texUnit->CombineModeA = GL_MODULATE;
815 texUnit->CombineSourceRGB[0] = GL_TEXTURE;
816 texUnit->CombineSourceRGB[1] = GL_PREVIOUS_EXT;
817 texUnit->CombineSourceRGB[2] = GL_CONSTANT_EXT;
818 texUnit->CombineSourceA[0] = GL_TEXTURE;
819 texUnit->CombineSourceA[1] = GL_PREVIOUS_EXT;
820 texUnit->CombineSourceA[2] = GL_CONSTANT_EXT;
821 texUnit->CombineOperandRGB[0] = GL_SRC_COLOR;
822 texUnit->CombineOperandRGB[1] = GL_SRC_COLOR;
823 texUnit->CombineOperandRGB[2] = GL_SRC_ALPHA;
824 texUnit->CombineOperandA[0] = GL_SRC_ALPHA;
825 texUnit->CombineOperandA[1] = GL_SRC_ALPHA;
826 texUnit->CombineOperandA[2] = GL_SRC_ALPHA;
827 texUnit->CombineScaleShiftRGB = 0;
828 texUnit->CombineScaleShiftA = 0;
829
830 ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
831 texUnit->TexGenEnabled = 0;
832 texUnit->GenModeS = GL_EYE_LINEAR;
833 texUnit->GenModeT = GL_EYE_LINEAR;
834 texUnit->GenModeR = GL_EYE_LINEAR;
835 texUnit->GenModeQ = GL_EYE_LINEAR;
836 texUnit->_GenBitS = TEXGEN_EYE_LINEAR;
837 texUnit->_GenBitT = TEXGEN_EYE_LINEAR;
838 texUnit->_GenBitR = TEXGEN_EYE_LINEAR;
839 texUnit->_GenBitQ = TEXGEN_EYE_LINEAR;
840
841 /* Yes, these plane coefficients are correct! */
842 ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 );
843 ASSIGN_4V( texUnit->ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 );
844 ASSIGN_4V( texUnit->ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 );
845 ASSIGN_4V( texUnit->ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 );
846 ASSIGN_4V( texUnit->EyePlaneS, 1.0, 0.0, 0.0, 0.0 );
847 ASSIGN_4V( texUnit->EyePlaneT, 0.0, 1.0, 0.0, 0.0 );
848 ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 );
849 ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 );
850
851 texUnit->Current1D = ctx->Shared->Default1D;
852 texUnit->Current2D = ctx->Shared->Default2D;
853 texUnit->Current3D = ctx->Shared->Default3D;
854 texUnit->CurrentCubeMap = ctx->Shared->DefaultCubeMap;
855 texUnit->CurrentRect = ctx->Shared->DefaultRect;
856 }
857
858
859
860
861 /* Initialize a 1-D evaluator map */
862 static void
863 init_1d_map( struct gl_1d_map *map, int n, const float *initial )
864 {
865 map->Order = 1;
866 map->u1 = 0.0;
867 map->u2 = 1.0;
868 map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat));
869 if (map->Points) {
870 GLint i;
871 for (i=0;i<n;i++)
872 map->Points[i] = initial[i];
873 }
874 }
875
876
877 /* Initialize a 2-D evaluator map */
878 static void
879 init_2d_map( struct gl_2d_map *map, int n, const float *initial )
880 {
881 map->Uorder = 1;
882 map->Vorder = 1;
883 map->u1 = 0.0;
884 map->u2 = 1.0;
885 map->v1 = 0.0;
886 map->v2 = 1.0;
887 map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat));
888 if (map->Points) {
889 GLint i;
890 for (i=0;i<n;i++)
891 map->Points[i] = initial[i];
892 }
893 }
894
895
896 /*
897 * Initialize the attribute groups in a GLcontext.
898 */
899 static void
900 init_attrib_groups( GLcontext *ctx )
901 {
902 GLuint i;
903
904 assert(ctx);
905
906 assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
907 assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
908
909 /* Constants, may be overriden by device drivers */
910 ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
911 ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
912 ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
913 ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
914 ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
915 ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
916 ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
917 ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
918 ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
919 ctx->Const.MinPointSize = MIN_POINT_SIZE;
920 ctx->Const.MaxPointSize = MAX_POINT_SIZE;
921 ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
922 ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
923 ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
924 ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
925 ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
926 ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
927 ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
928 ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
929 ctx->Const.NumAuxBuffers = NUM_AUX_BUFFERS;
930 ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
931 ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
932 ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
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
981 /* Current group */
982 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 0.0, 0.0, 0.0, 0.0 );
983 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 0.0 );
984 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
985 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 0.0 );
986 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_FOG], 0.0, 0.0, 0.0, 0.0 );
987 for (i = 0; i < MAX_TEXTURE_UNITS; i++)
988 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i], 0.0, 0.0, 0.0, 1.0 );
989 ctx->Current.Index = 1;
990 ctx->Current.EdgeFlag = GL_TRUE;
991
992 ASSIGN_4V( ctx->Current.RasterPos, 0.0, 0.0, 0.0, 1.0 );
993 ctx->Current.RasterDistance = 0.0;
994 ASSIGN_4V( ctx->Current.RasterColor, 1.0, 1.0, 1.0, 1.0 );
995 ctx->Current.RasterIndex = 1;
996 for (i=0; i<MAX_TEXTURE_UNITS; i++)
997 ASSIGN_4V( ctx->Current.RasterTexCoords[i], 0.0, 0.0, 0.0, 1.0 );
998 ctx->Current.RasterPosValid = GL_TRUE;
999
1000
1001 /* Depth buffer group */
1002 ctx->Depth.Test = GL_FALSE;
1003 ctx->Depth.Clear = 1.0;
1004 ctx->Depth.Func = GL_LESS;
1005 ctx->Depth.Mask = GL_TRUE;
1006 ctx->Depth.OcclusionTest = GL_FALSE;
1007
1008 /* Evaluators group */
1009 ctx->Eval.Map1Color4 = GL_FALSE;
1010 ctx->Eval.Map1Index = GL_FALSE;
1011 ctx->Eval.Map1Normal = GL_FALSE;
1012 ctx->Eval.Map1TextureCoord1 = GL_FALSE;
1013 ctx->Eval.Map1TextureCoord2 = GL_FALSE;
1014 ctx->Eval.Map1TextureCoord3 = GL_FALSE;
1015 ctx->Eval.Map1TextureCoord4 = GL_FALSE;
1016 ctx->Eval.Map1Vertex3 = GL_FALSE;
1017 ctx->Eval.Map1Vertex4 = GL_FALSE;
1018 MEMSET(ctx->Eval.Map1Attrib, 0, sizeof(ctx->Eval.Map1Attrib));
1019 ctx->Eval.Map2Color4 = GL_FALSE;
1020 ctx->Eval.Map2Index = GL_FALSE;
1021 ctx->Eval.Map2Normal = GL_FALSE;
1022 ctx->Eval.Map2TextureCoord1 = GL_FALSE;
1023 ctx->Eval.Map2TextureCoord2 = GL_FALSE;
1024 ctx->Eval.Map2TextureCoord3 = GL_FALSE;
1025 ctx->Eval.Map2TextureCoord4 = GL_FALSE;
1026 ctx->Eval.Map2Vertex3 = GL_FALSE;
1027 ctx->Eval.Map2Vertex4 = GL_FALSE;
1028 MEMSET(ctx->Eval.Map2Attrib, 0, sizeof(ctx->Eval.Map2Attrib));
1029 ctx->Eval.AutoNormal = GL_FALSE;
1030 ctx->Eval.MapGrid1un = 1;
1031 ctx->Eval.MapGrid1u1 = 0.0;
1032 ctx->Eval.MapGrid1u2 = 1.0;
1033 ctx->Eval.MapGrid2un = 1;
1034 ctx->Eval.MapGrid2vn = 1;
1035 ctx->Eval.MapGrid2u1 = 0.0;
1036 ctx->Eval.MapGrid2u2 = 1.0;
1037 ctx->Eval.MapGrid2v1 = 0.0;
1038 ctx->Eval.MapGrid2v2 = 1.0;
1039
1040 /* Evaluator data */
1041 {
1042 static GLfloat vertex[4] = { 0.0, 0.0, 0.0, 1.0 };
1043 static GLfloat normal[3] = { 0.0, 0.0, 1.0 };
1044 static GLfloat index[1] = { 1.0 };
1045 static GLfloat color[4] = { 1.0, 1.0, 1.0, 1.0 };
1046 static GLfloat texcoord[4] = { 0.0, 0.0, 0.0, 1.0 };
1047 static GLfloat attrib[4] = { 0.0, 0.0, 0.0, 1.0 };
1048
1049 init_1d_map( &ctx->EvalMap.Map1Vertex3, 3, vertex );
1050 init_1d_map( &ctx->EvalMap.Map1Vertex4, 4, vertex );
1051 init_1d_map( &ctx->EvalMap.Map1Index, 1, index );
1052 init_1d_map( &ctx->EvalMap.Map1Color4, 4, color );
1053 init_1d_map( &ctx->EvalMap.Map1Normal, 3, normal );
1054 init_1d_map( &ctx->EvalMap.Map1Texture1, 1, texcoord );
1055 init_1d_map( &ctx->EvalMap.Map1Texture2, 2, texcoord );
1056 init_1d_map( &ctx->EvalMap.Map1Texture3, 3, texcoord );
1057 init_1d_map( &ctx->EvalMap.Map1Texture4, 4, texcoord );
1058 for (i = 0; i < 16; i++)
1059 init_1d_map( ctx->EvalMap.Map1Attrib + i, 4, attrib );
1060
1061 init_2d_map( &ctx->EvalMap.Map2Vertex3, 3, vertex );
1062 init_2d_map( &ctx->EvalMap.Map2Vertex4, 4, vertex );
1063 init_2d_map( &ctx->EvalMap.Map2Index, 1, index );
1064 init_2d_map( &ctx->EvalMap.Map2Color4, 4, color );
1065 init_2d_map( &ctx->EvalMap.Map2Normal, 3, normal );
1066 init_2d_map( &ctx->EvalMap.Map2Texture1, 1, texcoord );
1067 init_2d_map( &ctx->EvalMap.Map2Texture2, 2, texcoord );
1068 init_2d_map( &ctx->EvalMap.Map2Texture3, 3, texcoord );
1069 init_2d_map( &ctx->EvalMap.Map2Texture4, 4, texcoord );
1070 for (i = 0; i < 16; i++)
1071 init_2d_map( ctx->EvalMap.Map2Attrib + i, 4, attrib );
1072 }
1073
1074 /* Fog group */
1075 ctx->Fog.Enabled = GL_FALSE;
1076 ctx->Fog.Mode = GL_EXP;
1077 ASSIGN_4V( ctx->Fog.Color, 0.0, 0.0, 0.0, 0.0 );
1078 ctx->Fog.Index = 0.0;
1079 ctx->Fog.Density = 1.0;
1080 ctx->Fog.Start = 0.0;
1081 ctx->Fog.End = 1.0;
1082 ctx->Fog.ColorSumEnabled = GL_FALSE;
1083 ctx->Fog.FogCoordinateSource = GL_FRAGMENT_DEPTH_EXT;
1084
1085 /* Hint group */
1086 ctx->Hint.PerspectiveCorrection = GL_DONT_CARE;
1087 ctx->Hint.PointSmooth = GL_DONT_CARE;
1088 ctx->Hint.LineSmooth = GL_DONT_CARE;
1089 ctx->Hint.PolygonSmooth = GL_DONT_CARE;
1090 ctx->Hint.Fog = GL_DONT_CARE;
1091 ctx->Hint.ClipVolumeClipping = GL_DONT_CARE;
1092 ctx->Hint.TextureCompression = GL_DONT_CARE;
1093 ctx->Hint.GenerateMipmap = GL_DONT_CARE;
1094
1095 /* Histogram group */
1096 ctx->Histogram.Width = 0;
1097 ctx->Histogram.Format = GL_RGBA;
1098 ctx->Histogram.Sink = GL_FALSE;
1099 ctx->Histogram.RedSize = 0;
1100 ctx->Histogram.GreenSize = 0;
1101 ctx->Histogram.BlueSize = 0;
1102 ctx->Histogram.AlphaSize = 0;
1103 ctx->Histogram.LuminanceSize = 0;
1104 for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
1105 ctx->Histogram.Count[i][0] = 0;
1106 ctx->Histogram.Count[i][1] = 0;
1107 ctx->Histogram.Count[i][2] = 0;
1108 ctx->Histogram.Count[i][3] = 0;
1109 }
1110
1111 /* Min/Max group */
1112 ctx->MinMax.Format = GL_RGBA;
1113 ctx->MinMax.Sink = GL_FALSE;
1114 ctx->MinMax.Min[RCOMP] = 1000; ctx->MinMax.Max[RCOMP] = -1000;
1115 ctx->MinMax.Min[GCOMP] = 1000; ctx->MinMax.Max[GCOMP] = -1000;
1116 ctx->MinMax.Min[BCOMP] = 1000; ctx->MinMax.Max[BCOMP] = -1000;
1117 ctx->MinMax.Min[ACOMP] = 1000; ctx->MinMax.Max[ACOMP] = -1000;
1118
1119 /* Extensions */
1120 _mesa_extensions_ctr( ctx );
1121
1122 /* Lighting group */
1123 for (i=0;i<MAX_LIGHTS;i++) {
1124 init_light( &ctx->Light.Light[i], i );
1125 }
1126 make_empty_list( &ctx->Light.EnabledList );
1127
1128 init_lightmodel( &ctx->Light.Model );
1129 init_material( &ctx->Light.Material[0] );
1130 init_material( &ctx->Light.Material[1] );
1131 ctx->Light.ShadeModel = GL_SMOOTH;
1132 ctx->Light.Enabled = GL_FALSE;
1133 ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK;
1134 ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE;
1135 ctx->Light.ColorMaterialBitmask = _mesa_material_bitmask( ctx,
1136 GL_FRONT_AND_BACK,
1137 GL_AMBIENT_AND_DIFFUSE, ~0, 0 );
1138
1139 ctx->Light.ColorMaterialEnabled = GL_FALSE;
1140
1141 /* Lighting miscellaneous */
1142 ctx->_ShineTabList = MALLOC_STRUCT( gl_shine_tab );
1143 make_empty_list( ctx->_ShineTabList );
1144 for (i = 0 ; i < 10 ; i++) {
1145 struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab );
1146 s->shininess = -1;
1147 s->refcount = 0;
1148 insert_at_tail( ctx->_ShineTabList, s );
1149 }
1150
1151
1152 /* Line group */
1153 ctx->Line.SmoothFlag = GL_FALSE;
1154 ctx->Line.StippleFlag = GL_FALSE;
1155 ctx->Line.Width = 1.0;
1156 ctx->Line._Width = 1.0;
1157 ctx->Line.StipplePattern = 0xffff;
1158 ctx->Line.StippleFactor = 1;
1159
1160 /* Display List group */
1161 ctx->List.ListBase = 0;
1162
1163 /* Multisample */
1164 ctx->Multisample.Enabled = GL_FALSE;
1165 ctx->Multisample.SampleAlphaToCoverage = GL_FALSE;
1166 ctx->Multisample.SampleAlphaToOne = GL_FALSE;
1167 ctx->Multisample.SampleCoverage = GL_FALSE;
1168 ctx->Multisample.SampleCoverageValue = 1.0;
1169 ctx->Multisample.SampleCoverageInvert = GL_FALSE;
1170
1171 /* Pixel group */
1172 ctx->Pixel.RedBias = 0.0;
1173 ctx->Pixel.RedScale = 1.0;
1174 ctx->Pixel.GreenBias = 0.0;
1175 ctx->Pixel.GreenScale = 1.0;
1176 ctx->Pixel.BlueBias = 0.0;
1177 ctx->Pixel.BlueScale = 1.0;
1178 ctx->Pixel.AlphaBias = 0.0;
1179 ctx->Pixel.AlphaScale = 1.0;
1180 ctx->Pixel.DepthBias = 0.0;
1181 ctx->Pixel.DepthScale = 1.0;
1182 ctx->Pixel.IndexOffset = 0;
1183 ctx->Pixel.IndexShift = 0;
1184 ctx->Pixel.ZoomX = 1.0;
1185 ctx->Pixel.ZoomY = 1.0;
1186 ctx->Pixel.MapColorFlag = GL_FALSE;
1187 ctx->Pixel.MapStencilFlag = GL_FALSE;
1188 ctx->Pixel.MapStoSsize = 1;
1189 ctx->Pixel.MapItoIsize = 1;
1190 ctx->Pixel.MapItoRsize = 1;
1191 ctx->Pixel.MapItoGsize = 1;
1192 ctx->Pixel.MapItoBsize = 1;
1193 ctx->Pixel.MapItoAsize = 1;
1194 ctx->Pixel.MapRtoRsize = 1;
1195 ctx->Pixel.MapGtoGsize = 1;
1196 ctx->Pixel.MapBtoBsize = 1;
1197 ctx->Pixel.MapAtoAsize = 1;
1198 ctx->Pixel.MapStoS[0] = 0;
1199 ctx->Pixel.MapItoI[0] = 0;
1200 ctx->Pixel.MapItoR[0] = 0.0;
1201 ctx->Pixel.MapItoG[0] = 0.0;
1202 ctx->Pixel.MapItoB[0] = 0.0;
1203 ctx->Pixel.MapItoA[0] = 0.0;
1204 ctx->Pixel.MapItoR8[0] = 0;
1205 ctx->Pixel.MapItoG8[0] = 0;
1206 ctx->Pixel.MapItoB8[0] = 0;
1207 ctx->Pixel.MapItoA8[0] = 0;
1208 ctx->Pixel.MapRtoR[0] = 0.0;
1209 ctx->Pixel.MapGtoG[0] = 0.0;
1210 ctx->Pixel.MapBtoB[0] = 0.0;
1211 ctx->Pixel.MapAtoA[0] = 0.0;
1212 ctx->Pixel.HistogramEnabled = GL_FALSE;
1213 ctx->Pixel.MinMaxEnabled = GL_FALSE;
1214 ctx->Pixel.PixelTextureEnabled = GL_FALSE;
1215 ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
1216 ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
1217 ASSIGN_4V(ctx->Pixel.PostColorMatrixScale, 1.0, 1.0, 1.0, 1.0);
1218 ASSIGN_4V(ctx->Pixel.PostColorMatrixBias, 0.0, 0.0, 0.0, 0.0);
1219 ASSIGN_4V(ctx->Pixel.ColorTableScale, 1.0, 1.0, 1.0, 1.0);
1220 ASSIGN_4V(ctx->Pixel.ColorTableBias, 0.0, 0.0, 0.0, 0.0);
1221 ASSIGN_4V(ctx->Pixel.PCCTscale, 1.0, 1.0, 1.0, 1.0);
1222 ASSIGN_4V(ctx->Pixel.PCCTbias, 0.0, 0.0, 0.0, 0.0);
1223 ASSIGN_4V(ctx->Pixel.PCMCTscale, 1.0, 1.0, 1.0, 1.0);
1224 ASSIGN_4V(ctx->Pixel.PCMCTbias, 0.0, 0.0, 0.0, 0.0);
1225 ctx->Pixel.ColorTableEnabled = GL_FALSE;
1226 ctx->Pixel.PostConvolutionColorTableEnabled = GL_FALSE;
1227 ctx->Pixel.PostColorMatrixColorTableEnabled = GL_FALSE;
1228 ctx->Pixel.Convolution1DEnabled = GL_FALSE;
1229 ctx->Pixel.Convolution2DEnabled = GL_FALSE;
1230 ctx->Pixel.Separable2DEnabled = GL_FALSE;
1231 for (i = 0; i < 3; i++) {
1232 ASSIGN_4V(ctx->Pixel.ConvolutionBorderColor[i], 0.0, 0.0, 0.0, 0.0);
1233 ctx->Pixel.ConvolutionBorderMode[i] = GL_REDUCE;
1234 ASSIGN_4V(ctx->Pixel.ConvolutionFilterScale[i], 1.0, 1.0, 1.0, 1.0);
1235 ASSIGN_4V(ctx->Pixel.ConvolutionFilterBias[i], 0.0, 0.0, 0.0, 0.0);
1236 }
1237 for (i = 0; i < MAX_CONVOLUTION_WIDTH * MAX_CONVOLUTION_WIDTH * 4; i++) {
1238 ctx->Convolution1D.Filter[i] = 0.0;
1239 ctx->Convolution2D.Filter[i] = 0.0;
1240 ctx->Separable2D.Filter[i] = 0.0;
1241 }
1242 ASSIGN_4V(ctx->Pixel.PostConvolutionScale, 1.0, 1.0, 1.0, 1.0);
1243 ASSIGN_4V(ctx->Pixel.PostConvolutionBias, 0.0, 0.0, 0.0, 0.0);
1244
1245 /* Point group */
1246 ctx->Point.SmoothFlag = GL_FALSE;
1247 ctx->Point.Size = 1.0;
1248 ctx->Point._Size = 1.0;
1249 ctx->Point.Params[0] = 1.0;
1250 ctx->Point.Params[1] = 0.0;
1251 ctx->Point.Params[2] = 0.0;
1252 ctx->Point._Attenuated = GL_FALSE;
1253 ctx->Point.MinSize = 0.0;
1254 ctx->Point.MaxSize = ctx->Const.MaxPointSize;
1255 ctx->Point.Threshold = 1.0;
1256 ctx->Point.PointSprite = GL_FALSE; /* GL_NV_point_sprite */
1257 ctx->Point.SpriteRMode = GL_ZERO; /* GL_NV_point_sprite */
1258 for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1259 ctx->Point.CoordReplace[i] = GL_FALSE; /* GL_NV_point_sprite */
1260 }
1261
1262 /* Polygon group */
1263 ctx->Polygon.CullFlag = GL_FALSE;
1264 ctx->Polygon.CullFaceMode = GL_BACK;
1265 ctx->Polygon.FrontFace = GL_CCW;
1266 ctx->Polygon._FrontBit = 0;
1267 ctx->Polygon.FrontMode = GL_FILL;
1268 ctx->Polygon.BackMode = GL_FILL;
1269 ctx->Polygon.SmoothFlag = GL_FALSE;
1270 ctx->Polygon.StippleFlag = GL_FALSE;
1271 ctx->Polygon.OffsetFactor = 0.0F;
1272 ctx->Polygon.OffsetUnits = 0.0F;
1273 ctx->Polygon.OffsetMRD = 0.0F;
1274 ctx->Polygon.OffsetPoint = GL_FALSE;
1275 ctx->Polygon.OffsetLine = GL_FALSE;
1276 ctx->Polygon.OffsetFill = GL_FALSE;
1277
1278 /* Polygon Stipple group */
1279 MEMSET( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) );
1280
1281 /* Scissor group */
1282 ctx->Scissor.Enabled = GL_FALSE;
1283 ctx->Scissor.X = 0;
1284 ctx->Scissor.Y = 0;
1285 ctx->Scissor.Width = 0;
1286 ctx->Scissor.Height = 0;
1287
1288 /* Stencil group */
1289 ctx->Stencil.Enabled = GL_FALSE;
1290 ctx->Stencil.TestTwoSide = GL_FALSE;
1291 ctx->Stencil.ActiveFace = 0; /* 0 = GL_FRONT, 1 = GL_BACK */
1292 ctx->Stencil.Function[0] = GL_ALWAYS;
1293 ctx->Stencil.Function[1] = GL_ALWAYS;
1294 ctx->Stencil.FailFunc[0] = GL_KEEP;
1295 ctx->Stencil.FailFunc[1] = GL_KEEP;
1296 ctx->Stencil.ZPassFunc[0] = GL_KEEP;
1297 ctx->Stencil.ZPassFunc[1] = GL_KEEP;
1298 ctx->Stencil.ZFailFunc[0] = GL_KEEP;
1299 ctx->Stencil.ZFailFunc[1] = GL_KEEP;
1300 ctx->Stencil.Ref[0] = 0;
1301 ctx->Stencil.Ref[1] = 0;
1302 ctx->Stencil.ValueMask[0] = STENCIL_MAX;
1303 ctx->Stencil.ValueMask[1] = STENCIL_MAX;
1304 ctx->Stencil.WriteMask[0] = STENCIL_MAX;
1305 ctx->Stencil.WriteMask[1] = STENCIL_MAX;
1306 ctx->Stencil.Clear = 0;
1307
1308 /* Texture group */
1309 ctx->Texture.CurrentUnit = 0; /* multitexture */
1310 ctx->Texture._ReallyEnabled = 0; /* XXX obsolete */
1311 ctx->Texture._EnabledUnits = 0;
1312 for (i=0; i<MAX_TEXTURE_UNITS; i++)
1313 init_texture_unit( ctx, i );
1314 ctx->Texture.SharedPalette = GL_FALSE;
1315 _mesa_init_colortable(&ctx->Texture.Palette);
1316
1317 /* Transformation group */
1318 ctx->Transform.MatrixMode = GL_MODELVIEW;
1319 ctx->Transform.Normalize = GL_FALSE;
1320 ctx->Transform.RescaleNormals = GL_FALSE;
1321 ctx->Transform.RasterPositionUnclipped = GL_FALSE;
1322 for (i=0;i<MAX_CLIP_PLANES;i++) {
1323 ASSIGN_4V( ctx->Transform.EyeUserPlane[i], 0.0, 0.0, 0.0, 0.0 );
1324 }
1325 ctx->Transform.ClipPlanesEnabled = 0;
1326
1327 /* Viewport group */
1328 ctx->Viewport.X = 0;
1329 ctx->Viewport.Y = 0;
1330 ctx->Viewport.Width = 0;
1331 ctx->Viewport.Height = 0;
1332 ctx->Viewport.Near = 0.0;
1333 ctx->Viewport.Far = 1.0;
1334 _math_matrix_ctr(&ctx->Viewport._WindowMap);
1335
1336 #define Sz 10
1337 #define Tz 14
1338 ctx->Viewport._WindowMap.m[Sz] = 0.5F * ctx->DepthMaxF;
1339 ctx->Viewport._WindowMap.m[Tz] = 0.5F * ctx->DepthMaxF;
1340 #undef Sz
1341 #undef Tz
1342
1343 ctx->Viewport._WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
1344 ctx->Viewport._WindowMap.type = MATRIX_3D_NO_ROT;
1345
1346 /* Vertex arrays */
1347 ctx->Array.Vertex.Size = 4;
1348 ctx->Array.Vertex.Type = GL_FLOAT;
1349 ctx->Array.Vertex.Stride = 0;
1350 ctx->Array.Vertex.StrideB = 0;
1351 ctx->Array.Vertex.Ptr = NULL;
1352 ctx->Array.Vertex.Enabled = GL_FALSE;
1353 ctx->Array.Vertex.Flags = CA_CLIENT_DATA;
1354 ctx->Array.Normal.Type = GL_FLOAT;
1355 ctx->Array.Normal.Stride = 0;
1356 ctx->Array.Normal.StrideB = 0;
1357 ctx->Array.Normal.Ptr = NULL;
1358 ctx->Array.Normal.Enabled = GL_FALSE;
1359 ctx->Array.Normal.Flags = CA_CLIENT_DATA;
1360 ctx->Array.Color.Size = 4;
1361 ctx->Array.Color.Type = GL_FLOAT;
1362 ctx->Array.Color.Stride = 0;
1363 ctx->Array.Color.StrideB = 0;
1364 ctx->Array.Color.Ptr = NULL;
1365 ctx->Array.Color.Enabled = GL_FALSE;
1366 ctx->Array.Color.Flags = CA_CLIENT_DATA;
1367 ctx->Array.SecondaryColor.Size = 4;
1368 ctx->Array.SecondaryColor.Type = GL_FLOAT;
1369 ctx->Array.SecondaryColor.Stride = 0;
1370 ctx->Array.SecondaryColor.StrideB = 0;
1371 ctx->Array.SecondaryColor.Ptr = NULL;
1372 ctx->Array.SecondaryColor.Enabled = GL_FALSE;
1373 ctx->Array.SecondaryColor.Flags = CA_CLIENT_DATA;
1374 ctx->Array.FogCoord.Size = 1;
1375 ctx->Array.FogCoord.Type = GL_FLOAT;
1376 ctx->Array.FogCoord.Stride = 0;
1377 ctx->Array.FogCoord.StrideB = 0;
1378 ctx->Array.FogCoord.Ptr = NULL;
1379 ctx->Array.FogCoord.Enabled = GL_FALSE;
1380 ctx->Array.FogCoord.Flags = CA_CLIENT_DATA;
1381 ctx->Array.Index.Type = GL_FLOAT;
1382 ctx->Array.Index.Stride = 0;
1383 ctx->Array.Index.StrideB = 0;
1384 ctx->Array.Index.Ptr = NULL;
1385 ctx->Array.Index.Enabled = GL_FALSE;
1386 ctx->Array.Index.Flags = CA_CLIENT_DATA;
1387 for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1388 ctx->Array.TexCoord[i].Size = 4;
1389 ctx->Array.TexCoord[i].Type = GL_FLOAT;
1390 ctx->Array.TexCoord[i].Stride = 0;
1391 ctx->Array.TexCoord[i].StrideB = 0;
1392 ctx->Array.TexCoord[i].Ptr = NULL;
1393 ctx->Array.TexCoord[i].Enabled = GL_FALSE;
1394 ctx->Array.TexCoord[i].Flags = CA_CLIENT_DATA;
1395 }
1396 ctx->Array.TexCoordInterleaveFactor = 1;
1397 ctx->Array.EdgeFlag.Stride = 0;
1398 ctx->Array.EdgeFlag.StrideB = 0;
1399 ctx->Array.EdgeFlag.Ptr = NULL;
1400 ctx->Array.EdgeFlag.Enabled = GL_FALSE;
1401 ctx->Array.EdgeFlag.Flags = CA_CLIENT_DATA;
1402 ctx->Array.ActiveTexture = 0; /* GL_ARB_multitexture */
1403
1404 /* Pixel transfer */
1405 ctx->Pack.Alignment = 4;
1406 ctx->Pack.RowLength = 0;
1407 ctx->Pack.ImageHeight = 0;
1408 ctx->Pack.SkipPixels = 0;
1409 ctx->Pack.SkipRows = 0;
1410 ctx->Pack.SkipImages = 0;
1411 ctx->Pack.SwapBytes = GL_FALSE;
1412 ctx->Pack.LsbFirst = GL_FALSE;
1413 ctx->Unpack.Alignment = 4;
1414 ctx->Unpack.RowLength = 0;
1415 ctx->Unpack.ImageHeight = 0;
1416 ctx->Unpack.SkipPixels = 0;
1417 ctx->Unpack.SkipRows = 0;
1418 ctx->Unpack.SkipImages = 0;
1419 ctx->Unpack.SwapBytes = GL_FALSE;
1420 ctx->Unpack.LsbFirst = GL_FALSE;
1421
1422 /* Feedback */
1423 ctx->Feedback.Type = GL_2D; /* TODO: verify */
1424 ctx->Feedback.Buffer = NULL;
1425 ctx->Feedback.BufferSize = 0;
1426 ctx->Feedback.Count = 0;
1427
1428 /* Selection/picking */
1429 ctx->Select.Buffer = NULL;
1430 ctx->Select.BufferSize = 0;
1431 ctx->Select.BufferCount = 0;
1432 ctx->Select.Hits = 0;
1433 ctx->Select.NameStackDepth = 0;
1434
1435 /* Renderer and client attribute stacks */
1436 ctx->AttribStackDepth = 0;
1437 ctx->ClientAttribStackDepth = 0;
1438
1439 /* Display list */
1440 ctx->CallDepth = 0;
1441 ctx->ExecuteFlag = GL_TRUE;
1442 ctx->CompileFlag = GL_FALSE;
1443 ctx->CurrentListPtr = NULL;
1444 ctx->CurrentBlock = NULL;
1445 ctx->CurrentListNum = 0;
1446 ctx->CurrentPos = 0;
1447
1448 /* Color tables */
1449 _mesa_init_colortable(&ctx->ColorTable);
1450 _mesa_init_colortable(&ctx->ProxyColorTable);
1451 _mesa_init_colortable(&ctx->PostConvolutionColorTable);
1452 _mesa_init_colortable(&ctx->ProxyPostConvolutionColorTable);
1453 _mesa_init_colortable(&ctx->PostColorMatrixColorTable);
1454 _mesa_init_colortable(&ctx->ProxyPostColorMatrixColorTable);
1455
1456 /* GL_NV_vertex_program */
1457 ctx->VertexProgram.Enabled = GL_FALSE;
1458 ctx->VertexProgram.PointSizeEnabled = GL_FALSE;
1459 ctx->VertexProgram.TwoSideEnabled = GL_FALSE;
1460 ctx->VertexProgram.CurrentID = 0;
1461 ctx->VertexProgram.ErrorPos = -1;
1462 ctx->VertexProgram.Current = NULL;
1463 for (i = 0; i < VP_NUM_PROG_REGS / 4; i++) {
1464 ctx->VertexProgram.TrackMatrix[i] = GL_NONE;
1465 ctx->VertexProgram.TrackMatrixTransform[i] = GL_IDENTITY_NV;
1466 }
1467
1468 /* Miscellaneous */
1469 ctx->NewState = _NEW_ALL;
1470 ctx->RenderMode = GL_RENDER;
1471 ctx->_ImageTransferState = 0;
1472
1473 ctx->_NeedNormals = 0;
1474 ctx->_NeedEyeCoords = 0;
1475 ctx->_ModelViewInvScale = 1.0;
1476
1477 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1478
1479 ctx->CatchSignals = GL_TRUE;
1480 ctx->OcclusionResult = GL_FALSE;
1481 ctx->OcclusionResultSaved = GL_FALSE;
1482
1483 /* For debug/development only */
1484 ctx->NoRaster = ctx->imports.getenv(ctx, "MESA_NO_RASTER") ? GL_TRUE : GL_FALSE;
1485 ctx->FirstTimeCurrent = GL_TRUE;
1486
1487 /* Dither disable */
1488 ctx->NoDither = ctx->imports.getenv(ctx, "MESA_NO_DITHER") ? GL_TRUE : GL_FALSE;
1489 if (ctx->NoDither) {
1490 if (ctx->imports.getenv(ctx, "MESA_DEBUG")) {
1491 _mesa_debug(ctx, "MESA_NO_DITHER set - dithering disabled\n");
1492 }
1493 ctx->Color.DitherFlag = GL_FALSE;
1494 }
1495 }
1496
1497
1498
1499
1500 /*
1501 * Allocate the proxy textures. If we run out of memory part way through
1502 * the allocations clean up and return GL_FALSE.
1503 * Return: GL_TRUE=success, GL_FALSE=failure
1504 */
1505 static GLboolean
1506 alloc_proxy_textures( GLcontext *ctx )
1507 {
1508 GLboolean out_of_memory;
1509 GLint i;
1510
1511 ctx->Texture.Proxy1D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_1D);
1512 if (!ctx->Texture.Proxy1D) {
1513 return GL_FALSE;
1514 }
1515
1516 ctx->Texture.Proxy2D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_2D);
1517 if (!ctx->Texture.Proxy2D) {
1518 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1519 return GL_FALSE;
1520 }
1521
1522 ctx->Texture.Proxy3D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_3D);
1523 if (!ctx->Texture.Proxy3D) {
1524 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1525 _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
1526 return GL_FALSE;
1527 }
1528
1529 ctx->Texture.ProxyCubeMap = _mesa_alloc_texture_object(NULL, 0,
1530 GL_TEXTURE_CUBE_MAP_ARB);
1531 if (!ctx->Texture.ProxyCubeMap) {
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 return GL_FALSE;
1536 }
1537
1538 ctx->Texture.ProxyRect = _mesa_alloc_texture_object(NULL, 0,
1539 GL_TEXTURE_RECTANGLE_NV);
1540 if (!ctx->Texture.ProxyRect) {
1541 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1542 _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
1543 _mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
1544 _mesa_free_texture_object(NULL, ctx->Texture.ProxyCubeMap);
1545 return GL_FALSE;
1546 }
1547
1548 out_of_memory = GL_FALSE;
1549 for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1550 ctx->Texture.Proxy1D->Image[i] = _mesa_alloc_texture_image();
1551 ctx->Texture.Proxy2D->Image[i] = _mesa_alloc_texture_image();
1552 ctx->Texture.Proxy3D->Image[i] = _mesa_alloc_texture_image();
1553 ctx->Texture.ProxyCubeMap->Image[i] = _mesa_alloc_texture_image();
1554 if (!ctx->Texture.Proxy1D->Image[i]
1555 || !ctx->Texture.Proxy2D->Image[i]
1556 || !ctx->Texture.Proxy3D->Image[i]
1557 || !ctx->Texture.ProxyCubeMap->Image[i]) {
1558 out_of_memory = GL_TRUE;
1559 }
1560 }
1561 ctx->Texture.ProxyRect->Image[0] = _mesa_alloc_texture_image();
1562 if (!ctx->Texture.ProxyRect->Image[0])
1563 out_of_memory = GL_TRUE;
1564
1565 if (out_of_memory) {
1566 for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1567 if (ctx->Texture.Proxy1D->Image[i]) {
1568 _mesa_free_texture_image(ctx->Texture.Proxy1D->Image[i]);
1569 }
1570 if (ctx->Texture.Proxy2D->Image[i]) {
1571 _mesa_free_texture_image(ctx->Texture.Proxy2D->Image[i]);
1572 }
1573 if (ctx->Texture.Proxy3D->Image[i]) {
1574 _mesa_free_texture_image(ctx->Texture.Proxy3D->Image[i]);
1575 }
1576 if (ctx->Texture.ProxyCubeMap->Image[i]) {
1577 _mesa_free_texture_image(ctx->Texture.ProxyCubeMap->Image[i]);
1578 }
1579 }
1580 if (ctx->Texture.ProxyRect->Image[0]) {
1581 _mesa_free_texture_image(ctx->Texture.ProxyRect->Image[0]);
1582 }
1583 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1584 _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
1585 _mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
1586 _mesa_free_texture_object(NULL, ctx->Texture.ProxyCubeMap);
1587 _mesa_free_texture_object(NULL, ctx->Texture.ProxyRect);
1588 return GL_FALSE;
1589 }
1590 else {
1591 return GL_TRUE;
1592 }
1593 }
1594
1595
1596 static void add_debug_flags( const char *debug )
1597 {
1598 #ifdef MESA_DEBUG
1599 if (strstr(debug, "varray"))
1600 MESA_VERBOSE |= VERBOSE_VARRAY;
1601
1602 if (strstr(debug, "tex"))
1603 MESA_VERBOSE |= VERBOSE_TEXTURE;
1604
1605 if (strstr(debug, "imm"))
1606 MESA_VERBOSE |= VERBOSE_IMMEDIATE;
1607
1608 if (strstr(debug, "pipe"))
1609 MESA_VERBOSE |= VERBOSE_PIPELINE;
1610
1611 if (strstr(debug, "driver"))
1612 MESA_VERBOSE |= VERBOSE_DRIVER;
1613
1614 if (strstr(debug, "state"))
1615 MESA_VERBOSE |= VERBOSE_STATE;
1616
1617 if (strstr(debug, "api"))
1618 MESA_VERBOSE |= VERBOSE_API;
1619
1620 if (strstr(debug, "list"))
1621 MESA_VERBOSE |= VERBOSE_DISPLAY_LIST;
1622
1623 if (strstr(debug, "lighting"))
1624 MESA_VERBOSE |= VERBOSE_LIGHTING;
1625
1626 /* Debug flag:
1627 */
1628 if (strstr(debug, "flush"))
1629 MESA_DEBUG_FLAGS |= DEBUG_ALWAYS_FLUSH;
1630 #endif
1631 }
1632
1633
1634 /*
1635 * Initialize a GLcontext struct. This includes allocating all the
1636 * other structs and arrays which hang off of the context by pointers.
1637 */
1638 GLboolean
1639 _mesa_initialize_context( GLcontext *ctx,
1640 const GLvisual *visual,
1641 GLcontext *share_list,
1642 const __GLimports *imports )
1643 {
1644 GLuint dispatchSize;
1645
1646 ASSERT(imports);
1647 ASSERT(imports->other); /* other points to the device driver's context */
1648
1649 /* assing imports */
1650 ctx->imports = *imports;
1651
1652 /* initialize the exports (Mesa functions called by the window system) */
1653 _mesa_init_default_exports( &(ctx->exports) );
1654
1655 /* misc one-time initializations */
1656 one_time_init(ctx);
1657
1658 #if 0
1659 /**
1660 ** OpenGL SI stuff
1661 **/
1662 if (!ctx->imports.malloc) {
1663 _mesa_init_default_imports(&ctx->imports, driver_ctx);
1664 }
1665 /* exports are setup by the device driver */
1666 #endif
1667
1668 ctx->DriverCtx = imports->other;
1669 ctx->Visual = *visual;
1670 ctx->DrawBuffer = NULL;
1671 ctx->ReadBuffer = NULL;
1672
1673 if (share_list) {
1674 /* share state with another context */
1675 ctx->Shared = share_list->Shared;
1676 }
1677 else {
1678 /* allocate new, unshared state */
1679 ctx->Shared = alloc_shared_state();
1680 if (!ctx->Shared) {
1681 return GL_FALSE;
1682 }
1683 }
1684 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1685 ctx->Shared->RefCount++;
1686 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1687
1688 /* Effectively bind the default textures to all texture units */
1689 ctx->Shared->Default1D->RefCount += MAX_TEXTURE_UNITS;
1690 ctx->Shared->Default2D->RefCount += MAX_TEXTURE_UNITS;
1691 ctx->Shared->Default3D->RefCount += MAX_TEXTURE_UNITS;
1692 ctx->Shared->DefaultCubeMap->RefCount += MAX_TEXTURE_UNITS;
1693 ctx->Shared->DefaultRect->RefCount += MAX_TEXTURE_UNITS;
1694
1695 init_attrib_groups( ctx );
1696
1697 if (visual->doubleBufferMode) {
1698 ctx->Color.DrawBuffer = GL_BACK;
1699 ctx->Color._DriverDrawBuffer = GL_BACK_LEFT;
1700 ctx->Color._DrawDestMask = BACK_LEFT_BIT;
1701 ctx->Pixel.ReadBuffer = GL_BACK;
1702 ctx->Pixel._DriverReadBuffer = GL_BACK_LEFT;
1703 }
1704 else {
1705 ctx->Color.DrawBuffer = GL_FRONT;
1706 ctx->Color._DriverDrawBuffer = GL_FRONT_LEFT;
1707 ctx->Color._DrawDestMask = FRONT_LEFT_BIT;
1708 ctx->Pixel.ReadBuffer = GL_FRONT;
1709 ctx->Pixel._DriverReadBuffer = GL_FRONT_LEFT;
1710 }
1711
1712 if (!alloc_proxy_textures(ctx)) {
1713 free_shared_state(ctx, ctx->Shared);
1714 return GL_FALSE;
1715 }
1716
1717 /* register the most recent extension functions with libGL */
1718 _glapi_add_entrypoint("glTbufferMask3DFX", 553);
1719 _glapi_add_entrypoint("glCompressedTexImage3DARB", 554);
1720 _glapi_add_entrypoint("glCompressedTexImage2DARB", 555);
1721 _glapi_add_entrypoint("glCompressedTexImage1DARB", 556);
1722 _glapi_add_entrypoint("glCompressedTexSubImage3DARB", 557);
1723 _glapi_add_entrypoint("glCompressedTexSubImage2DARB", 558);
1724 _glapi_add_entrypoint("glCompressedTexSubImage1DARB", 559);
1725 _glapi_add_entrypoint("glGetCompressedTexImageARB", 560);
1726 /* XXX we should add a bunch of new functions here */
1727
1728
1729 /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1730 * In practice, this'll be the same for stand-alone Mesa. But for DRI
1731 * Mesa we do this to accomodate different versions of libGL and various
1732 * DRI drivers.
1733 */
1734 dispatchSize = MAX2(_glapi_get_dispatch_table_size(),
1735 sizeof(struct _glapi_table) / sizeof(void *));
1736
1737 /* setup API dispatch tables */
1738 ctx->Exec = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
1739 ctx->Save = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
1740 if (!ctx->Exec || !ctx->Save) {
1741 free_shared_state(ctx, ctx->Shared);
1742 if (ctx->Exec)
1743 FREE( ctx->Exec );
1744 }
1745 _mesa_init_exec_table(ctx->Exec, dispatchSize);
1746 _mesa_init_dlist_table(ctx->Save, dispatchSize);
1747 ctx->CurrentDispatch = ctx->Exec;
1748
1749 ctx->ExecPrefersFloat = GL_FALSE;
1750 ctx->SavePrefersFloat = GL_FALSE;
1751
1752 /* Neutral tnl module stuff */
1753 _mesa_init_exec_vtxfmt( ctx );
1754 ctx->TnlModule.Current = NULL;
1755 ctx->TnlModule.SwapCount = 0;
1756
1757 /* Z buffer stuff */
1758 if (ctx->Visual.depthBits == 0) {
1759 /* Special case. Even if we don't have a depth buffer we need
1760 * good values for DepthMax for Z vertex transformation purposes
1761 * and for per-fragment fog computation.
1762 */
1763 ctx->DepthMax = 1 << 16;
1764 ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
1765 }
1766 else if (ctx->Visual.depthBits < 32) {
1767 ctx->DepthMax = (1 << ctx->Visual.depthBits) - 1;
1768 ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
1769 }
1770 else {
1771 /* Special case since shift values greater than or equal to the
1772 * number of bits in the left hand expression's type are undefined.
1773 */
1774 ctx->DepthMax = 0xffffffff;
1775 ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
1776 }
1777 ctx->MRD = 1.0; /* Minimum resolvable depth value, for polygon offset */
1778
1779
1780 #if defined(MESA_TRACE)
1781 ctx->TraceCtx = (trace_context_t *) CALLOC( sizeof(trace_context_t) );
1782 #if 0
1783 /* Brian: do you want to have CreateContext fail here,
1784 or should we just trap in NewTrace (currently done)? */
1785 if (!(ctx->TraceCtx)) {
1786 free_shared_state(ctx, ctx->Shared);
1787 FREE( ctx->Exec );
1788 FREE( ctx->Save );
1789 return GL_FALSE;
1790 }
1791 #endif
1792 trInitContext(ctx->TraceCtx);
1793
1794 ctx->TraceDispatch = (struct _glapi_table *)
1795 CALLOC(dispatchSize * sizeof(void*));
1796 #if 0
1797 if (!(ctx->TraceCtx)) {
1798 free_shared_state(ctx, ctx->Shared);
1799 FREE( ctx->Exec );
1800 FREE( ctx->Save );
1801 FREE( ctx->TraceCtx );
1802 return GL_FALSE;
1803 }
1804 #endif
1805 trInitDispatch(ctx->TraceDispatch);
1806 #endif
1807
1808
1809 if (ctx->imports.getenv(ctx, "MESA_DEBUG"))
1810 add_debug_flags(ctx->imports.getenv(ctx, "MESA_DEBUG"));
1811
1812 if (ctx->imports.getenv(ctx, "MESA_VERBOSE"))
1813 add_debug_flags(ctx->imports.getenv(ctx, "MESA_VERBOSE"));
1814
1815 return GL_TRUE;
1816 }
1817
1818
1819
1820 /*
1821 * Allocate and initialize a GLcontext structure.
1822 * Input: visual - a GLvisual pointer (we copy the struct contents)
1823 * sharelist - another context to share display lists with or NULL
1824 * imports - points to a fully-initialized __GLimports object.
1825 * Return: pointer to a new __GLcontextRec or NULL if error.
1826 */
1827 GLcontext *
1828 _mesa_create_context( const GLvisual *visual,
1829 GLcontext *share_list,
1830 const __GLimports *imports )
1831 {
1832 GLcontext *ctx;
1833
1834 ASSERT(visual);
1835 ASSERT(imports);
1836 ASSERT(imports->calloc);
1837
1838 ctx = (GLcontext *) imports->calloc(NULL, 1, sizeof(GLcontext));
1839 if (!ctx)
1840 return NULL;
1841
1842 ctx->Driver.CurrentExecPrimitive = 0; /* XXX why is this here??? */
1843
1844 if (_mesa_initialize_context(ctx, visual, share_list, imports)) {
1845 return ctx;
1846 }
1847 else {
1848 imports->free(NULL, ctx);
1849 return NULL;
1850 }
1851 }
1852
1853
1854
1855 /*
1856 * Free the data associated with the given context.
1857 * But don't free() the GLcontext struct itself!
1858 */
1859 void
1860 _mesa_free_context_data( GLcontext *ctx )
1861 {
1862 struct gl_shine_tab *s, *tmps;
1863 GLuint i;
1864
1865 /* if we're destroying the current context, unbind it first */
1866 if (ctx == _mesa_get_current_context()) {
1867 _mesa_make_current(NULL, NULL);
1868 }
1869
1870 /*
1871 * Free transformation matrix stacks
1872 */
1873 free_matrix_stack(&ctx->ModelviewMatrixStack);
1874 free_matrix_stack(&ctx->ProjectionMatrixStack);
1875 free_matrix_stack(&ctx->ColorMatrixStack);
1876 for (i = 0; i < MAX_TEXTURE_UNITS; i++)
1877 free_matrix_stack(&ctx->TextureMatrixStack[i]);
1878 for (i = 0; i < MAX_PROGRAM_MATRICES; i++)
1879 free_matrix_stack(&ctx->ProgramMatrixStack[i]);
1880 /* combined Modelview*Projection matrix */
1881 _math_matrix_dtr( &ctx->_ModelProjectMatrix );
1882
1883
1884 if (ctx->VertexProgram.Current) {
1885 ctx->VertexProgram.Current->RefCount--;
1886 if (ctx->VertexProgram.Current->RefCount <= 0)
1887 _mesa_delete_program(ctx, ctx->VertexProgram.CurrentID);
1888 }
1889
1890 /* Shared context state (display lists, textures, etc) */
1891 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1892 ctx->Shared->RefCount--;
1893 assert(ctx->Shared->RefCount >= 0);
1894 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1895 if (ctx->Shared->RefCount == 0) {
1896 /* free shared state */
1897 free_shared_state( ctx, ctx->Shared );
1898 }
1899
1900 /* Free lighting shininess exponentiation table */
1901 foreach_s( s, tmps, ctx->_ShineTabList ) {
1902 FREE( s );
1903 }
1904 FREE( ctx->_ShineTabList );
1905
1906 /* Free proxy texture objects */
1907 _mesa_free_texture_object( NULL, ctx->Texture.Proxy1D );
1908 _mesa_free_texture_object( NULL, ctx->Texture.Proxy2D );
1909 _mesa_free_texture_object( NULL, ctx->Texture.Proxy3D );
1910 _mesa_free_texture_object( NULL, ctx->Texture.ProxyCubeMap );
1911 _mesa_free_texture_object( NULL, ctx->Texture.ProxyRect );
1912
1913 /* Free evaluator data */
1914 if (ctx->EvalMap.Map1Vertex3.Points)
1915 FREE( ctx->EvalMap.Map1Vertex3.Points );
1916 if (ctx->EvalMap.Map1Vertex4.Points)
1917 FREE( ctx->EvalMap.Map1Vertex4.Points );
1918 if (ctx->EvalMap.Map1Index.Points)
1919 FREE( ctx->EvalMap.Map1Index.Points );
1920 if (ctx->EvalMap.Map1Color4.Points)
1921 FREE( ctx->EvalMap.Map1Color4.Points );
1922 if (ctx->EvalMap.Map1Normal.Points)
1923 FREE( ctx->EvalMap.Map1Normal.Points );
1924 if (ctx->EvalMap.Map1Texture1.Points)
1925 FREE( ctx->EvalMap.Map1Texture1.Points );
1926 if (ctx->EvalMap.Map1Texture2.Points)
1927 FREE( ctx->EvalMap.Map1Texture2.Points );
1928 if (ctx->EvalMap.Map1Texture3.Points)
1929 FREE( ctx->EvalMap.Map1Texture3.Points );
1930 if (ctx->EvalMap.Map1Texture4.Points)
1931 FREE( ctx->EvalMap.Map1Texture4.Points );
1932 for (i = 0; i < 16; i++)
1933 FREE((ctx->EvalMap.Map1Attrib[i].Points));
1934
1935 if (ctx->EvalMap.Map2Vertex3.Points)
1936 FREE( ctx->EvalMap.Map2Vertex3.Points );
1937 if (ctx->EvalMap.Map2Vertex4.Points)
1938 FREE( ctx->EvalMap.Map2Vertex4.Points );
1939 if (ctx->EvalMap.Map2Index.Points)
1940 FREE( ctx->EvalMap.Map2Index.Points );
1941 if (ctx->EvalMap.Map2Color4.Points)
1942 FREE( ctx->EvalMap.Map2Color4.Points );
1943 if (ctx->EvalMap.Map2Normal.Points)
1944 FREE( ctx->EvalMap.Map2Normal.Points );
1945 if (ctx->EvalMap.Map2Texture1.Points)
1946 FREE( ctx->EvalMap.Map2Texture1.Points );
1947 if (ctx->EvalMap.Map2Texture2.Points)
1948 FREE( ctx->EvalMap.Map2Texture2.Points );
1949 if (ctx->EvalMap.Map2Texture3.Points)
1950 FREE( ctx->EvalMap.Map2Texture3.Points );
1951 if (ctx->EvalMap.Map2Texture4.Points)
1952 FREE( ctx->EvalMap.Map2Texture4.Points );
1953 for (i = 0; i < 16; i++)
1954 FREE((ctx->EvalMap.Map2Attrib[i].Points));
1955
1956 _mesa_free_colortable_data( &ctx->ColorTable );
1957 _mesa_free_colortable_data( &ctx->PostConvolutionColorTable );
1958 _mesa_free_colortable_data( &ctx->PostColorMatrixColorTable );
1959 _mesa_free_colortable_data( &ctx->Texture.Palette );
1960
1961 _math_matrix_dtr(&ctx->Viewport._WindowMap);
1962
1963 _mesa_extensions_dtr(ctx);
1964
1965 FREE(ctx->Exec);
1966 FREE(ctx->Save);
1967 }
1968
1969
1970
1971 /*
1972 * Destroy a GLcontext structure.
1973 */
1974 void
1975 _mesa_destroy_context( GLcontext *ctx )
1976 {
1977 if (ctx) {
1978 _mesa_free_context_data(ctx);
1979 FREE( (void *) ctx );
1980 }
1981 }
1982
1983
1984
1985 /*
1986 * Copy attribute groups from one context to another.
1987 * Input: src - source context
1988 * dst - destination context
1989 * mask - bitwise OR of GL_*_BIT flags
1990 */
1991 void
1992 _mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1993 {
1994 if (mask & GL_ACCUM_BUFFER_BIT) {
1995 /* OK to memcpy */
1996 dst->Accum = src->Accum;
1997 }
1998 if (mask & GL_COLOR_BUFFER_BIT) {
1999 /* OK to memcpy */
2000 dst->Color = src->Color;
2001 }
2002 if (mask & GL_CURRENT_BIT) {
2003 /* OK to memcpy */
2004 dst->Current = src->Current;
2005 }
2006 if (mask & GL_DEPTH_BUFFER_BIT) {
2007 /* OK to memcpy */
2008 dst->Depth = src->Depth;
2009 }
2010 if (mask & GL_ENABLE_BIT) {
2011 /* no op */
2012 }
2013 if (mask & GL_EVAL_BIT) {
2014 /* OK to memcpy */
2015 dst->Eval = src->Eval;
2016 }
2017 if (mask & GL_FOG_BIT) {
2018 /* OK to memcpy */
2019 dst->Fog = src->Fog;
2020 }
2021 if (mask & GL_HINT_BIT) {
2022 /* OK to memcpy */
2023 dst->Hint = src->Hint;
2024 }
2025 if (mask & GL_LIGHTING_BIT) {
2026 GLuint i;
2027 /* begin with memcpy */
2028 MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light) );
2029 /* fixup linked lists to prevent pointer insanity */
2030 make_empty_list( &(dst->Light.EnabledList) );
2031 for (i = 0; i < MAX_LIGHTS; i++) {
2032 if (dst->Light.Light[i].Enabled) {
2033 insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
2034 }
2035 }
2036 }
2037 if (mask & GL_LINE_BIT) {
2038 /* OK to memcpy */
2039 dst->Line = src->Line;
2040 }
2041 if (mask & GL_LIST_BIT) {
2042 /* OK to memcpy */
2043 dst->List = src->List;
2044 }
2045 if (mask & GL_PIXEL_MODE_BIT) {
2046 /* OK to memcpy */
2047 dst->Pixel = src->Pixel;
2048 }
2049 if (mask & GL_POINT_BIT) {
2050 /* OK to memcpy */
2051 dst->Point = src->Point;
2052 }
2053 if (mask & GL_POLYGON_BIT) {
2054 /* OK to memcpy */
2055 dst->Polygon = src->Polygon;
2056 }
2057 if (mask & GL_POLYGON_STIPPLE_BIT) {
2058 /* Use loop instead of MEMCPY due to problem with Portland Group's
2059 * C compiler. Reported by John Stone.
2060 */
2061 GLuint i;
2062 for (i = 0; i < 32; i++) {
2063 dst->PolygonStipple[i] = src->PolygonStipple[i];
2064 }
2065 }
2066 if (mask & GL_SCISSOR_BIT) {
2067 /* OK to memcpy */
2068 dst->Scissor = src->Scissor;
2069 }
2070 if (mask & GL_STENCIL_BUFFER_BIT) {
2071 /* OK to memcpy */
2072 dst->Stencil = src->Stencil;
2073 }
2074 if (mask & GL_TEXTURE_BIT) {
2075 /* Cannot memcpy because of pointers */
2076 _mesa_copy_texture_state(src, dst);
2077 }
2078 if (mask & GL_TRANSFORM_BIT) {
2079 /* OK to memcpy */
2080 dst->Transform = src->Transform;
2081 }
2082 if (mask & GL_VIEWPORT_BIT) {
2083 /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
2084 dst->Viewport.X = src->Viewport.X;
2085 dst->Viewport.Y = src->Viewport.Y;
2086 dst->Viewport.Width = src->Viewport.Width;
2087 dst->Viewport.Height = src->Viewport.Height;
2088 dst->Viewport.Near = src->Viewport.Near;
2089 dst->Viewport.Far = src->Viewport.Far;
2090 _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
2091 }
2092
2093 /* XXX FIXME: Call callbacks?
2094 */
2095 dst->NewState = _NEW_ALL;
2096 }
2097
2098
2099
2100 static void print_info( void )
2101 {
2102 _mesa_debug(NULL, "Mesa GL_VERSION = %s\n",
2103 (char *) _mesa_GetString(GL_VERSION));
2104 _mesa_debug(NULL, "Mesa GL_RENDERER = %s\n",
2105 (char *) _mesa_GetString(GL_RENDERER));
2106 _mesa_debug(NULL, "Mesa GL_VENDOR = %s\n",
2107 (char *) _mesa_GetString(GL_VENDOR));
2108 _mesa_debug(NULL, "Mesa GL_EXTENSIONS = %s\n",
2109 (char *) _mesa_GetString(GL_EXTENSIONS));
2110 #if defined(THREADS)
2111 _mesa_debug(NULL, "Mesa thread-safe: YES\n");
2112 #else
2113 _mesa_debug(NULL, "Mesa thread-safe: NO\n");
2114 #endif
2115 #if defined(USE_X86_ASM)
2116 _mesa_debug(NULL, "Mesa x86-optimized: YES\n");
2117 #else
2118 _mesa_debug(NULL, "Mesa x86-optimized: NO\n");
2119 #endif
2120 #if defined(USE_SPARC_ASM)
2121 _mesa_debug(NULL, "Mesa sparc-optimized: YES\n");
2122 #else
2123 _mesa_debug(NULL, "Mesa sparc-optimized: NO\n");
2124 #endif
2125 }
2126
2127
2128 /*
2129 * Set the current context, binding the given frame buffer to the context.
2130 */
2131 void
2132 _mesa_make_current( GLcontext *newCtx, GLframebuffer *buffer )
2133 {
2134 _mesa_make_current2( newCtx, buffer, buffer );
2135 }
2136
2137
2138 /*
2139 * Bind the given context to the given draw-buffer and read-buffer
2140 * and make it the current context for this thread.
2141 */
2142 void
2143 _mesa_make_current2( GLcontext *newCtx, GLframebuffer *drawBuffer,
2144 GLframebuffer *readBuffer )
2145 {
2146 if (MESA_VERBOSE)
2147 _mesa_debug(newCtx, "_mesa_make_current2()\n");
2148
2149 /* Check that the context's and framebuffer's visuals are compatible.
2150 * We could do a lot more checking here but this'll catch obvious
2151 * problems.
2152 */
2153 if (newCtx && drawBuffer && readBuffer) {
2154 if (newCtx->Visual.rgbMode != drawBuffer->Visual.rgbMode ||
2155 newCtx->Visual.redBits != drawBuffer->Visual.redBits ||
2156 newCtx->Visual.depthBits != drawBuffer->Visual.depthBits ||
2157 newCtx->Visual.stencilBits != drawBuffer->Visual.stencilBits ||
2158 newCtx->Visual.accumRedBits != drawBuffer->Visual.accumRedBits) {
2159 return; /* incompatible */
2160 }
2161 }
2162
2163 /* We call this function periodically (just here for now) in
2164 * order to detect when multithreading has begun.
2165 */
2166 _glapi_check_multithread();
2167
2168 _glapi_set_context((void *) newCtx);
2169 ASSERT(_mesa_get_current_context() == newCtx);
2170
2171
2172 if (!newCtx) {
2173 _glapi_set_dispatch(NULL); /* none current */
2174 }
2175 else {
2176 _glapi_set_dispatch(newCtx->CurrentDispatch);
2177
2178 if (drawBuffer && readBuffer) {
2179 /* TODO: check if newCtx and buffer's visual match??? */
2180 newCtx->DrawBuffer = drawBuffer;
2181 newCtx->ReadBuffer = readBuffer;
2182 newCtx->NewState |= _NEW_BUFFERS;
2183
2184 if (drawBuffer->Width == 0 && drawBuffer->Height == 0) {
2185 /* get initial window size */
2186 GLuint bufWidth, bufHeight;
2187
2188 /* ask device driver for size of output buffer */
2189 (*newCtx->Driver.GetBufferSize)( drawBuffer, &bufWidth, &bufHeight );
2190
2191 if (drawBuffer->Width == bufWidth && drawBuffer->Height == bufHeight)
2192 return; /* size is as expected */
2193
2194 drawBuffer->Width = bufWidth;
2195 drawBuffer->Height = bufHeight;
2196
2197 newCtx->Driver.ResizeBuffers( drawBuffer );
2198 }
2199
2200 if (readBuffer != drawBuffer &&
2201 readBuffer->Width == 0 && readBuffer->Height == 0) {
2202 /* get initial window size */
2203 GLuint bufWidth, bufHeight;
2204
2205 /* ask device driver for size of output buffer */
2206 (*newCtx->Driver.GetBufferSize)( readBuffer, &bufWidth, &bufHeight );
2207
2208 if (readBuffer->Width == bufWidth && readBuffer->Height == bufHeight)
2209 return; /* size is as expected */
2210
2211 readBuffer->Width = bufWidth;
2212 readBuffer->Height = bufHeight;
2213
2214 newCtx->Driver.ResizeBuffers( readBuffer );
2215 }
2216 }
2217
2218 /* This is only for T&L - a bit out of place, or misnamed (BP) */
2219 if (newCtx->Driver.MakeCurrent)
2220 newCtx->Driver.MakeCurrent( newCtx, drawBuffer, readBuffer );
2221
2222 /* We can use this to help debug user's problems. Tell them to set
2223 * the MESA_INFO env variable before running their app. Then the
2224 * first time each context is made current we'll print some useful
2225 * information.
2226 */
2227 if (newCtx->FirstTimeCurrent) {
2228 if (newCtx->imports.getenv(newCtx, "MESA_INFO")) {
2229 print_info();
2230 }
2231 newCtx->FirstTimeCurrent = GL_FALSE;
2232 }
2233 }
2234 }
2235
2236
2237
2238 /*
2239 * Return current context handle for the calling thread.
2240 * This isn't the fastest way to get the current context.
2241 * If you need speed, see the GET_CURRENT_CONTEXT() macro in context.h
2242 */
2243 GLcontext *
2244 _mesa_get_current_context( void )
2245 {
2246 return (GLcontext *) _glapi_get_context();
2247 }
2248
2249
2250
2251 /*
2252 * This should be called by device drivers just before they do a
2253 * swapbuffers. Any pending rendering commands will be executed.
2254 * XXX we should really rename this function to _mesa_flush() or something.
2255 */
2256 void
2257 _mesa_swapbuffers(GLcontext *ctx)
2258 {
2259 FLUSH_VERTICES( ctx, 0 );
2260 }
2261
2262
2263
2264 /*
2265 * Return pointer to this context's current API dispatch table.
2266 * It'll either be the immediate-mode execute dispatcher or the
2267 * display list compile dispatcher.
2268 */
2269 struct _glapi_table *
2270 _mesa_get_dispatch(GLcontext *ctx)
2271 {
2272 return ctx->CurrentDispatch;
2273 }
2274
2275
2276
2277 /**********************************************************************/
2278 /***** Miscellaneous functions *****/
2279 /**********************************************************************/
2280
2281
2282 /*
2283 * Record the given error code and call the driver's Error function if defined.
2284 * This is called via _mesa_error().
2285 */
2286 void
2287 _mesa_record_error( GLcontext *ctx, GLenum error )
2288 {
2289 if (!ctx)
2290 return;
2291
2292 if (ctx->ErrorValue == GL_NO_ERROR) {
2293 ctx->ErrorValue = error;
2294 }
2295
2296 /* Call device driver's error handler, if any. This is used on the Mac. */
2297 if (ctx->Driver.Error) {
2298 (*ctx->Driver.Error)( ctx );
2299 }
2300 }
2301
2302
2303 void
2304 _mesa_Finish( void )
2305 {
2306 GET_CURRENT_CONTEXT(ctx);
2307 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
2308 if (ctx->Driver.Finish) {
2309 (*ctx->Driver.Finish)( ctx );
2310 }
2311 }
2312
2313
2314
2315 void
2316 _mesa_Flush( void )
2317 {
2318 GET_CURRENT_CONTEXT(ctx);
2319 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
2320 if (ctx->Driver.Flush) {
2321 (*ctx->Driver.Flush)( ctx );
2322 }
2323 }
2324
2325
2326
2327 const char *_mesa_prim_name[GL_POLYGON+4] = {
2328 "GL_POINTS",
2329 "GL_LINES",
2330 "GL_LINE_LOOP",
2331 "GL_LINE_STRIP",
2332 "GL_TRIANGLES",
2333 "GL_TRIANGLE_STRIP",
2334 "GL_TRIANGLE_FAN",
2335 "GL_QUADS",
2336 "GL_QUAD_STRIP",
2337 "GL_POLYGON",
2338 "outside begin/end",
2339 "inside unkown primitive",
2340 "unknown state"
2341 };