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