projects / mesa.git / blob
? search:


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