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