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