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