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