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