projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added new bitfields to tnl_eval_store for NV_vertex_program evaluators
[mesa.git] / src / mesa / main / context.c
1 /* $Id: context.c,v 1.172 2002/06/18 16:53:46 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 }
583 else {
584 _glapi_noop_enable_warnings(GL_FALSE);
585 }
586
587 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
588 fprintf(stderr, "Mesa DEBUG build %s %s\n", __DATE__, __TIME__);
589 #endif
590
591 alreadyCalled = GL_TRUE;
592 }
593 _glthread_UNLOCK_MUTEX(OneTimeLock);
594 }
595
596
597 static void
598 init_matrix_stack( struct matrix_stack *stack,
599 GLuint maxDepth, GLuint dirtyFlag )
600 {
601 GLuint i;
602
603 stack->Depth = 0;
604 stack->MaxDepth = maxDepth;
605 stack->DirtyFlag = dirtyFlag;
606 /* The stack */
607 stack->Stack = (GLmatrix *) CALLOC(maxDepth * sizeof(GLmatrix));
608 for (i = 0; i < maxDepth; i++) {
609 _math_matrix_ctr(&stack->Stack[i]);
610 _math_matrix_alloc_inv(&stack->Stack[i]);
611 }
612 stack->Top = stack->Stack;
613 }
614
615
616 static void
617 free_matrix_stack( struct matrix_stack *stack )
618 {
619 GLuint i;
620 for (i = 0; i < stack->MaxDepth; i++) {
621 _math_matrix_dtr(&stack->Stack[i]);
622 }
623 FREE(stack->Stack);
624 stack->Stack = stack->Top = NULL;
625 }
626
627
628 /*
629 * Allocate and initialize a shared context state structure.
630 */
631 static struct gl_shared_state *
632 alloc_shared_state( void )
633 {
634 struct gl_shared_state *ss;
635 GLboolean outOfMemory;
636
637 ss = CALLOC_STRUCT(gl_shared_state);
638 if (!ss)
639 return NULL;
640
641 _glthread_INIT_MUTEX(ss->Mutex);
642
643 ss->DisplayList = _mesa_NewHashTable();
644 ss->TexObjects = _mesa_NewHashTable();
645 ss->VertexPrograms = _mesa_NewHashTable();
646
647 /* Default Texture objects */
648 outOfMemory = GL_FALSE;
649
650 ss->Default1D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_1D);
651 if (!ss->Default1D) {
652 outOfMemory = GL_TRUE;
653 }
654
655 ss->Default2D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_2D);
656 if (!ss->Default2D) {
657 outOfMemory = GL_TRUE;
658 }
659
660 ss->Default3D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_3D);
661 if (!ss->Default3D) {
662 outOfMemory = GL_TRUE;
663 }
664
665 ss->DefaultCubeMap = _mesa_alloc_texture_object(ss, 0,
666 GL_TEXTURE_CUBE_MAP_ARB);
667 if (!ss->DefaultCubeMap) {
668 outOfMemory = GL_TRUE;
669 }
670
671 ss->DefaultRect = _mesa_alloc_texture_object(ss, 0,
672 GL_TEXTURE_RECTANGLE_NV);
673 if (!ss->DefaultRect) {
674 outOfMemory = GL_TRUE;
675 }
676
677 if (!ss->DisplayList || !ss->TexObjects || !ss->VertexPrograms
678 || outOfMemory) {
679 /* Ran out of memory at some point. Free everything and return NULL */
680 if (ss->DisplayList)
681 _mesa_DeleteHashTable(ss->DisplayList);
682 if (ss->TexObjects)
683 _mesa_DeleteHashTable(ss->TexObjects);
684 if (ss->VertexPrograms)
685 _mesa_DeleteHashTable(ss->VertexPrograms);
686 if (ss->Default1D)
687 _mesa_free_texture_object(ss, ss->Default1D);
688 if (ss->Default2D)
689 _mesa_free_texture_object(ss, ss->Default2D);
690 if (ss->Default3D)
691 _mesa_free_texture_object(ss, ss->Default3D);
692 if (ss->DefaultCubeMap)
693 _mesa_free_texture_object(ss, ss->DefaultCubeMap);
694 if (ss->DefaultRect)
695 _mesa_free_texture_object(ss, ss->DefaultRect);
696 FREE(ss);
697 return NULL;
698 }
699 else {
700 return ss;
701 }
702 }
703
704
705 /*
706 * Deallocate a shared state context and all children structures.
707 */
708 static void
709 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
710 {
711 /* Free display lists */
712 while (1) {
713 GLuint list = _mesa_HashFirstEntry(ss->DisplayList);
714 if (list) {
715 _mesa_destroy_list(ctx, list);
716 }
717 else {
718 break;
719 }
720 }
721 _mesa_DeleteHashTable(ss->DisplayList);
722
723 /* Free texture objects */
724 while (ss->TexObjectList) {
725 if (ctx->Driver.DeleteTexture)
726 (*ctx->Driver.DeleteTexture)( ctx, ss->TexObjectList );
727 /* this function removes from linked list too! */
728 _mesa_free_texture_object(ss, ss->TexObjectList);
729 }
730 _mesa_DeleteHashTable(ss->TexObjects);
731
732 /* Free vertex programs */
733 while (1) {
734 GLuint prog = _mesa_HashFirstEntry(ss->VertexPrograms);
735 if (prog) {
736 _mesa_delete_program(ctx, prog);
737 }
738 else {
739 break;
740 }
741 }
742 _mesa_DeleteHashTable(ss->VertexPrograms);
743
744 FREE(ss);
745 }
746
747
748
749 /*
750 * Initialize the nth light. Note that the defaults for light 0 are
751 * different than the other lights.
752 */
753 static void
754 init_light( struct gl_light *l, GLuint n )
755 {
756 make_empty_list( l );
757
758 ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 );
759 if (n==0) {
760 ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 );
761 ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 );
762 }
763 else {
764 ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 );
765 ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 );
766 }
767 ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 );
768 ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 );
769 l->SpotExponent = 0.0;
770 _mesa_invalidate_spot_exp_table( l );
771 l->SpotCutoff = 180.0;
772 l->_CosCutoff = 0.0; /* KW: -ve values not admitted */
773 l->ConstantAttenuation = 1.0;
774 l->LinearAttenuation = 0.0;
775 l->QuadraticAttenuation = 0.0;
776 l->Enabled = GL_FALSE;
777 }
778
779
780
781 static void
782 init_lightmodel( struct gl_lightmodel *lm )
783 {
784 ASSIGN_4V( lm->Ambient, 0.2F, 0.2F, 0.2F, 1.0F );
785 lm->LocalViewer = GL_FALSE;
786 lm->TwoSide = GL_FALSE;
787 lm->ColorControl = GL_SINGLE_COLOR;
788 }
789
790
791 static void
792 init_material( struct gl_material *m )
793 {
794 ASSIGN_4V( m->Ambient, 0.2F, 0.2F, 0.2F, 1.0F );
795 ASSIGN_4V( m->Diffuse, 0.8F, 0.8F, 0.8F, 1.0F );
796 ASSIGN_4V( m->Specular, 0.0F, 0.0F, 0.0F, 1.0F );
797 ASSIGN_4V( m->Emission, 0.0F, 0.0F, 0.0F, 1.0F );
798 m->Shininess = 0.0;
799 m->AmbientIndex = 0;
800 m->DiffuseIndex = 1;
801 m->SpecularIndex = 1;
802 }
803
804
805
806 static void
807 init_texture_unit( GLcontext *ctx, GLuint unit )
808 {
809 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
810
811 texUnit->EnvMode = GL_MODULATE;
812 texUnit->CombineModeRGB = GL_MODULATE;
813 texUnit->CombineModeA = GL_MODULATE;
814 texUnit->CombineSourceRGB[0] = GL_TEXTURE;
815 texUnit->CombineSourceRGB[1] = GL_PREVIOUS_EXT;
816 texUnit->CombineSourceRGB[2] = GL_CONSTANT_EXT;
817 texUnit->CombineSourceA[0] = GL_TEXTURE;
818 texUnit->CombineSourceA[1] = GL_PREVIOUS_EXT;
819 texUnit->CombineSourceA[2] = GL_CONSTANT_EXT;
820 texUnit->CombineOperandRGB[0] = GL_SRC_COLOR;
821 texUnit->CombineOperandRGB[1] = GL_SRC_COLOR;
822 texUnit->CombineOperandRGB[2] = GL_SRC_ALPHA;
823 texUnit->CombineOperandA[0] = GL_SRC_ALPHA;
824 texUnit->CombineOperandA[1] = GL_SRC_ALPHA;
825 texUnit->CombineOperandA[2] = GL_SRC_ALPHA;
826 texUnit->CombineScaleShiftRGB = 0;
827 texUnit->CombineScaleShiftA = 0;
828
829 ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
830 texUnit->TexGenEnabled = 0;
831 texUnit->GenModeS = GL_EYE_LINEAR;
832 texUnit->GenModeT = GL_EYE_LINEAR;
833 texUnit->GenModeR = GL_EYE_LINEAR;
834 texUnit->GenModeQ = GL_EYE_LINEAR;
835 texUnit->_GenBitS = TEXGEN_EYE_LINEAR;
836 texUnit->_GenBitT = TEXGEN_EYE_LINEAR;
837 texUnit->_GenBitR = TEXGEN_EYE_LINEAR;
838 texUnit->_GenBitQ = TEXGEN_EYE_LINEAR;
839
840 /* Yes, these plane coefficients are correct! */
841 ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 );
842 ASSIGN_4V( texUnit->ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 );
843 ASSIGN_4V( texUnit->ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 );
844 ASSIGN_4V( texUnit->ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 );
845 ASSIGN_4V( texUnit->EyePlaneS, 1.0, 0.0, 0.0, 0.0 );
846 ASSIGN_4V( texUnit->EyePlaneT, 0.0, 1.0, 0.0, 0.0 );
847 ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 );
848 ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 );
849
850 texUnit->Current1D = ctx->Shared->Default1D;
851 texUnit->Current2D = ctx->Shared->Default2D;
852 texUnit->Current3D = ctx->Shared->Default3D;
853 texUnit->CurrentCubeMap = ctx->Shared->DefaultCubeMap;
854 texUnit->CurrentRect = ctx->Shared->DefaultRect;
855 }
856
857
858
859
860 /* Initialize a 1-D evaluator map */
861 static void
862 init_1d_map( struct gl_1d_map *map, int n, const float *initial )
863 {
864 map->Order = 1;
865 map->u1 = 0.0;
866 map->u2 = 1.0;
867 map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat));
868 if (map->Points) {
869 GLint i;
870 for (i=0;i<n;i++)
871 map->Points[i] = initial[i];
872 }
873 }
874
875
876 /* Initialize a 2-D evaluator map */
877 static void
878 init_2d_map( struct gl_2d_map *map, int n, const float *initial )
879 {
880 map->Uorder = 1;
881 map->Vorder = 1;
882 map->u1 = 0.0;
883 map->u2 = 1.0;
884 map->v1 = 0.0;
885 map->v2 = 1.0;
886 map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat));
887 if (map->Points) {
888 GLint i;
889 for (i=0;i<n;i++)
890 map->Points[i] = initial[i];
891 }
892 }
893
894
895 /*
896 * Initialize the attribute groups in a GLcontext.
897 */
898 static void
899 init_attrib_groups( GLcontext *ctx )
900 {
901 GLuint i;
902
903 assert(ctx);
904
905 assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
906 assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
907
908 /* Constants, may be overriden by device drivers */
909 ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
910 ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
911 ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
912 ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
913 ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
914 ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
915 ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
916 ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
917 ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
918 ctx->Const.MinPointSize = MIN_POINT_SIZE;
919 ctx->Const.MaxPointSize = MAX_POINT_SIZE;
920 ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
921 ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
922 ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
923 ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
924 ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
925 ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
926 ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
927 ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
928 ctx->Const.NumAuxBuffers = NUM_AUX_BUFFERS;
929 ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
930 ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
931 ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
932 ctx->Const.NumCompressedTextureFormats = 0;
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 ctx->Color.MultiDrawBuffer = GL_FALSE;
981
982 /* Current group */
983 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 0.0, 0.0, 0.0, 0.0 );
984 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 0.0 );
985 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
986 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 0.0 );
987 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_FOG], 0.0, 0.0, 0.0, 0.0 );
988 for (i = 0; i < MAX_TEXTURE_UNITS; i++)
989 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i], 0.0, 0.0, 0.0, 1.0 );
990 ctx->Current.Index = 1;
991 ctx->Current.EdgeFlag = GL_TRUE;
992
993 ASSIGN_4V( ctx->Current.RasterPos, 0.0, 0.0, 0.0, 1.0 );
994 ctx->Current.RasterDistance = 0.0;
995 ASSIGN_4V( ctx->Current.RasterColor, 1.0, 1.0, 1.0, 1.0 );
996 ctx->Current.RasterIndex = 1;
997 for (i=0; i<MAX_TEXTURE_UNITS; i++)
998 ASSIGN_4V( ctx->Current.RasterTexCoords[i], 0.0, 0.0, 0.0, 1.0 );
999 ctx->Current.RasterPosValid = GL_TRUE;
1000
1001
1002 /* Depth buffer group */
1003 ctx->Depth.Test = GL_FALSE;
1004 ctx->Depth.Clear = 1.0;
1005 ctx->Depth.Func = GL_LESS;
1006 ctx->Depth.Mask = GL_TRUE;
1007 ctx->Depth.OcclusionTest = GL_FALSE;
1008
1009 /* Evaluators group */
1010 ctx->Eval.Map1Color4 = GL_FALSE;
1011 ctx->Eval.Map1Index = GL_FALSE;
1012 ctx->Eval.Map1Normal = GL_FALSE;
1013 ctx->Eval.Map1TextureCoord1 = GL_FALSE;
1014 ctx->Eval.Map1TextureCoord2 = GL_FALSE;
1015 ctx->Eval.Map1TextureCoord3 = GL_FALSE;
1016 ctx->Eval.Map1TextureCoord4 = GL_FALSE;
1017 ctx->Eval.Map1Vertex3 = GL_FALSE;
1018 ctx->Eval.Map1Vertex4 = GL_FALSE;
1019 MEMSET(ctx->Eval.Map1Attrib, 0, sizeof(ctx->Eval.Map1Attrib));
1020 ctx->Eval.Map2Color4 = GL_FALSE;
1021 ctx->Eval.Map2Index = GL_FALSE;
1022 ctx->Eval.Map2Normal = GL_FALSE;
1023 ctx->Eval.Map2TextureCoord1 = GL_FALSE;
1024 ctx->Eval.Map2TextureCoord2 = GL_FALSE;
1025 ctx->Eval.Map2TextureCoord3 = GL_FALSE;
1026 ctx->Eval.Map2TextureCoord4 = GL_FALSE;
1027 ctx->Eval.Map2Vertex3 = GL_FALSE;
1028 ctx->Eval.Map2Vertex4 = GL_FALSE;
1029 MEMSET(ctx->Eval.Map2Attrib, 0, sizeof(ctx->Eval.Map2Attrib));
1030 ctx->Eval.AutoNormal = GL_FALSE;
1031 ctx->Eval.MapGrid1un = 1;
1032 ctx->Eval.MapGrid1u1 = 0.0;
1033 ctx->Eval.MapGrid1u2 = 1.0;
1034 ctx->Eval.MapGrid2un = 1;
1035 ctx->Eval.MapGrid2vn = 1;
1036 ctx->Eval.MapGrid2u1 = 0.0;
1037 ctx->Eval.MapGrid2u2 = 1.0;
1038 ctx->Eval.MapGrid2v1 = 0.0;
1039 ctx->Eval.MapGrid2v2 = 1.0;
1040
1041 /* Evaluator data */
1042 {
1043 static GLfloat vertex[4] = { 0.0, 0.0, 0.0, 1.0 };
1044 static GLfloat normal[3] = { 0.0, 0.0, 1.0 };
1045 static GLfloat index[1] = { 1.0 };
1046 static GLfloat color[4] = { 1.0, 1.0, 1.0, 1.0 };
1047 static GLfloat texcoord[4] = { 0.0, 0.0, 0.0, 1.0 };
1048 static GLfloat attrib[4] = { 0.0, 0.0, 0.0, 1.0 };
1049
1050 init_1d_map( &ctx->EvalMap.Map1Vertex3, 3, vertex );
1051 init_1d_map( &ctx->EvalMap.Map1Vertex4, 4, vertex );
1052 init_1d_map( &ctx->EvalMap.Map1Index, 1, index );
1053 init_1d_map( &ctx->EvalMap.Map1Color4, 4, color );
1054 init_1d_map( &ctx->EvalMap.Map1Normal, 3, normal );
1055 init_1d_map( &ctx->EvalMap.Map1Texture1, 1, texcoord );
1056 init_1d_map( &ctx->EvalMap.Map1Texture2, 2, texcoord );
1057 init_1d_map( &ctx->EvalMap.Map1Texture3, 3, texcoord );
1058 init_1d_map( &ctx->EvalMap.Map1Texture4, 4, texcoord );
1059 for (i = 0; i < 16; i++)
1060 init_1d_map( ctx->EvalMap.Map1Attrib + i, 4, attrib );
1061
1062 init_2d_map( &ctx->EvalMap.Map2Vertex3, 3, vertex );
1063 init_2d_map( &ctx->EvalMap.Map2Vertex4, 4, vertex );
1064 init_2d_map( &ctx->EvalMap.Map2Index, 1, index );
1065 init_2d_map( &ctx->EvalMap.Map2Color4, 4, color );
1066 init_2d_map( &ctx->EvalMap.Map2Normal, 3, normal );
1067 init_2d_map( &ctx->EvalMap.Map2Texture1, 1, texcoord );
1068 init_2d_map( &ctx->EvalMap.Map2Texture2, 2, texcoord );
1069 init_2d_map( &ctx->EvalMap.Map2Texture3, 3, texcoord );
1070 init_2d_map( &ctx->EvalMap.Map2Texture4, 4, texcoord );
1071 for (i = 0; i < 16; i++)
1072 init_2d_map( ctx->EvalMap.Map2Attrib + i, 4, attrib );
1073 }
1074
1075 /* Fog group */
1076 ctx->Fog.Enabled = GL_FALSE;
1077 ctx->Fog.Mode = GL_EXP;
1078 ASSIGN_4V( ctx->Fog.Color, 0.0, 0.0, 0.0, 0.0 );
1079 ctx->Fog.Index = 0.0;
1080 ctx->Fog.Density = 1.0;
1081 ctx->Fog.Start = 0.0;
1082 ctx->Fog.End = 1.0;
1083 ctx->Fog.ColorSumEnabled = GL_FALSE;
1084 ctx->Fog.FogCoordinateSource = GL_FRAGMENT_DEPTH_EXT;
1085
1086 /* Hint group */
1087 ctx->Hint.PerspectiveCorrection = GL_DONT_CARE;
1088 ctx->Hint.PointSmooth = GL_DONT_CARE;
1089 ctx->Hint.LineSmooth = GL_DONT_CARE;
1090 ctx->Hint.PolygonSmooth = GL_DONT_CARE;
1091 ctx->Hint.Fog = GL_DONT_CARE;
1092 ctx->Hint.ClipVolumeClipping = GL_DONT_CARE;
1093 ctx->Hint.TextureCompression = GL_DONT_CARE;
1094 ctx->Hint.GenerateMipmap = GL_DONT_CARE;
1095
1096 /* Histogram group */
1097 ctx->Histogram.Width = 0;
1098 ctx->Histogram.Format = GL_RGBA;
1099 ctx->Histogram.Sink = GL_FALSE;
1100 ctx->Histogram.RedSize = 0;
1101 ctx->Histogram.GreenSize = 0;
1102 ctx->Histogram.BlueSize = 0;
1103 ctx->Histogram.AlphaSize = 0;
1104 ctx->Histogram.LuminanceSize = 0;
1105 for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
1106 ctx->Histogram.Count[i][0] = 0;
1107 ctx->Histogram.Count[i][1] = 0;
1108 ctx->Histogram.Count[i][2] = 0;
1109 ctx->Histogram.Count[i][3] = 0;
1110 }
1111
1112 /* Min/Max group */
1113 ctx->MinMax.Format = GL_RGBA;
1114 ctx->MinMax.Sink = GL_FALSE;
1115 ctx->MinMax.Min[RCOMP] = 1000; ctx->MinMax.Max[RCOMP] = -1000;
1116 ctx->MinMax.Min[GCOMP] = 1000; ctx->MinMax.Max[GCOMP] = -1000;
1117 ctx->MinMax.Min[BCOMP] = 1000; ctx->MinMax.Max[BCOMP] = -1000;
1118 ctx->MinMax.Min[ACOMP] = 1000; ctx->MinMax.Max[ACOMP] = -1000;
1119
1120 /* Extensions */
1121 _mesa_extensions_ctr( ctx );
1122
1123 /* Lighting group */
1124 for (i=0;i<MAX_LIGHTS;i++) {
1125 init_light( &ctx->Light.Light[i], i );
1126 }
1127 make_empty_list( &ctx->Light.EnabledList );
1128
1129 init_lightmodel( &ctx->Light.Model );
1130 init_material( &ctx->Light.Material[0] );
1131 init_material( &ctx->Light.Material[1] );
1132 ctx->Light.ShadeModel = GL_SMOOTH;
1133 ctx->Light.Enabled = GL_FALSE;
1134 ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK;
1135 ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE;
1136 ctx->Light.ColorMaterialBitmask = _mesa_material_bitmask( ctx,
1137 GL_FRONT_AND_BACK,
1138 GL_AMBIENT_AND_DIFFUSE, ~0, 0 );
1139
1140 ctx->Light.ColorMaterialEnabled = GL_FALSE;
1141
1142 /* Lighting miscellaneous */
1143 ctx->_ShineTabList = MALLOC_STRUCT( gl_shine_tab );
1144 make_empty_list( ctx->_ShineTabList );
1145 for (i = 0 ; i < 10 ; i++) {
1146 struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab );
1147 s->shininess = -1;
1148 s->refcount = 0;
1149 insert_at_tail( ctx->_ShineTabList, s );
1150 }
1151
1152
1153 /* Line group */
1154 ctx->Line.SmoothFlag = GL_FALSE;
1155 ctx->Line.StippleFlag = GL_FALSE;
1156 ctx->Line.Width = 1.0;
1157 ctx->Line._Width = 1.0;
1158 ctx->Line.StipplePattern = 0xffff;
1159 ctx->Line.StippleFactor = 1;
1160
1161 /* Display List group */
1162 ctx->List.ListBase = 0;
1163
1164 /* Multisample */
1165 ctx->Multisample.Enabled = GL_FALSE;
1166 ctx->Multisample.SampleAlphaToCoverage = GL_FALSE;
1167 ctx->Multisample.SampleAlphaToOne = GL_FALSE;
1168 ctx->Multisample.SampleCoverage = GL_FALSE;
1169 ctx->Multisample.SampleCoverageValue = 1.0;
1170 ctx->Multisample.SampleCoverageInvert = GL_FALSE;
1171
1172 /* Pixel group */
1173 ctx->Pixel.RedBias = 0.0;
1174 ctx->Pixel.RedScale = 1.0;
1175 ctx->Pixel.GreenBias = 0.0;
1176 ctx->Pixel.GreenScale = 1.0;
1177 ctx->Pixel.BlueBias = 0.0;
1178 ctx->Pixel.BlueScale = 1.0;
1179 ctx->Pixel.AlphaBias = 0.0;
1180 ctx->Pixel.AlphaScale = 1.0;
1181 ctx->Pixel.DepthBias = 0.0;
1182 ctx->Pixel.DepthScale = 1.0;
1183 ctx->Pixel.IndexOffset = 0;
1184 ctx->Pixel.IndexShift = 0;
1185 ctx->Pixel.ZoomX = 1.0;
1186 ctx->Pixel.ZoomY = 1.0;
1187 ctx->Pixel.MapColorFlag = GL_FALSE;
1188 ctx->Pixel.MapStencilFlag = GL_FALSE;
1189 ctx->Pixel.MapStoSsize = 1;
1190 ctx->Pixel.MapItoIsize = 1;
1191 ctx->Pixel.MapItoRsize = 1;
1192 ctx->Pixel.MapItoGsize = 1;
1193 ctx->Pixel.MapItoBsize = 1;
1194 ctx->Pixel.MapItoAsize = 1;
1195 ctx->Pixel.MapRtoRsize = 1;
1196 ctx->Pixel.MapGtoGsize = 1;
1197 ctx->Pixel.MapBtoBsize = 1;
1198 ctx->Pixel.MapAtoAsize = 1;
1199 ctx->Pixel.MapStoS[0] = 0;
1200 ctx->Pixel.MapItoI[0] = 0;
1201 ctx->Pixel.MapItoR[0] = 0.0;
1202 ctx->Pixel.MapItoG[0] = 0.0;
1203 ctx->Pixel.MapItoB[0] = 0.0;
1204 ctx->Pixel.MapItoA[0] = 0.0;
1205 ctx->Pixel.MapItoR8[0] = 0;
1206 ctx->Pixel.MapItoG8[0] = 0;
1207 ctx->Pixel.MapItoB8[0] = 0;
1208 ctx->Pixel.MapItoA8[0] = 0;
1209 ctx->Pixel.MapRtoR[0] = 0.0;
1210 ctx->Pixel.MapGtoG[0] = 0.0;
1211 ctx->Pixel.MapBtoB[0] = 0.0;
1212 ctx->Pixel.MapAtoA[0] = 0.0;
1213 ctx->Pixel.HistogramEnabled = GL_FALSE;
1214 ctx->Pixel.MinMaxEnabled = GL_FALSE;
1215 ctx->Pixel.PixelTextureEnabled = GL_FALSE;
1216 ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
1217 ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
1218 ASSIGN_4V(ctx->Pixel.PostColorMatrixScale, 1.0, 1.0, 1.0, 1.0);
1219 ASSIGN_4V(ctx->Pixel.PostColorMatrixBias, 0.0, 0.0, 0.0, 0.0);
1220 ASSIGN_4V(ctx->Pixel.ColorTableScale, 1.0, 1.0, 1.0, 1.0);
1221 ASSIGN_4V(ctx->Pixel.ColorTableBias, 0.0, 0.0, 0.0, 0.0);
1222 ASSIGN_4V(ctx->Pixel.PCCTscale, 1.0, 1.0, 1.0, 1.0);
1223 ASSIGN_4V(ctx->Pixel.PCCTbias, 0.0, 0.0, 0.0, 0.0);
1224 ASSIGN_4V(ctx->Pixel.PCMCTscale, 1.0, 1.0, 1.0, 1.0);
1225 ASSIGN_4V(ctx->Pixel.PCMCTbias, 0.0, 0.0, 0.0, 0.0);
1226 ctx->Pixel.ColorTableEnabled = GL_FALSE;
1227 ctx->Pixel.PostConvolutionColorTableEnabled = GL_FALSE;
1228 ctx->Pixel.PostColorMatrixColorTableEnabled = GL_FALSE;
1229 ctx->Pixel.Convolution1DEnabled = GL_FALSE;
1230 ctx->Pixel.Convolution2DEnabled = GL_FALSE;
1231 ctx->Pixel.Separable2DEnabled = GL_FALSE;
1232 for (i = 0; i < 3; i++) {
1233 ASSIGN_4V(ctx->Pixel.ConvolutionBorderColor[i], 0.0, 0.0, 0.0, 0.0);
1234 ctx->Pixel.ConvolutionBorderMode[i] = GL_REDUCE;
1235 ASSIGN_4V(ctx->Pixel.ConvolutionFilterScale[i], 1.0, 1.0, 1.0, 1.0);
1236 ASSIGN_4V(ctx->Pixel.ConvolutionFilterBias[i], 0.0, 0.0, 0.0, 0.0);
1237 }
1238 for (i = 0; i < MAX_CONVOLUTION_WIDTH * MAX_CONVOLUTION_WIDTH * 4; i++) {
1239 ctx->Convolution1D.Filter[i] = 0.0;
1240 ctx->Convolution2D.Filter[i] = 0.0;
1241 ctx->Separable2D.Filter[i] = 0.0;
1242 }
1243 ASSIGN_4V(ctx->Pixel.PostConvolutionScale, 1.0, 1.0, 1.0, 1.0);
1244 ASSIGN_4V(ctx->Pixel.PostConvolutionBias, 0.0, 0.0, 0.0, 0.0);
1245
1246 /* Point group */
1247 ctx->Point.SmoothFlag = GL_FALSE;
1248 ctx->Point.Size = 1.0;
1249 ctx->Point._Size = 1.0;
1250 ctx->Point.Params[0] = 1.0;
1251 ctx->Point.Params[1] = 0.0;
1252 ctx->Point.Params[2] = 0.0;
1253 ctx->Point._Attenuated = GL_FALSE;
1254 ctx->Point.MinSize = 0.0;
1255 ctx->Point.MaxSize = ctx->Const.MaxPointSize;
1256 ctx->Point.Threshold = 1.0;
1257 ctx->Point.PointSprite = GL_FALSE; /* GL_NV_point_sprite */
1258 ctx->Point.SpriteRMode = GL_ZERO; /* GL_NV_point_sprite */
1259 for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1260 ctx->Point.CoordReplace[i] = GL_FALSE; /* GL_NV_point_sprite */
1261 }
1262
1263 /* Polygon group */
1264 ctx->Polygon.CullFlag = GL_FALSE;
1265 ctx->Polygon.CullFaceMode = GL_BACK;
1266 ctx->Polygon.FrontFace = GL_CCW;
1267 ctx->Polygon._FrontBit = 0;
1268 ctx->Polygon.FrontMode = GL_FILL;
1269 ctx->Polygon.BackMode = GL_FILL;
1270 ctx->Polygon.SmoothFlag = GL_FALSE;
1271 ctx->Polygon.StippleFlag = GL_FALSE;
1272 ctx->Polygon.OffsetFactor = 0.0F;
1273 ctx->Polygon.OffsetUnits = 0.0F;
1274 ctx->Polygon.OffsetMRD = 0.0F;
1275 ctx->Polygon.OffsetPoint = GL_FALSE;
1276 ctx->Polygon.OffsetLine = GL_FALSE;
1277 ctx->Polygon.OffsetFill = GL_FALSE;
1278
1279 /* Polygon Stipple group */
1280 MEMSET( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) );
1281
1282 /* Scissor group */
1283 ctx->Scissor.Enabled = GL_FALSE;
1284 ctx->Scissor.X = 0;
1285 ctx->Scissor.Y = 0;
1286 ctx->Scissor.Width = 0;
1287 ctx->Scissor.Height = 0;
1288
1289 /* Stencil group */
1290 ctx->Stencil.Enabled = GL_FALSE;
1291 ctx->Stencil.Function = GL_ALWAYS;
1292 ctx->Stencil.FailFunc = GL_KEEP;
1293 ctx->Stencil.ZPassFunc = GL_KEEP;
1294 ctx->Stencil.ZFailFunc = GL_KEEP;
1295 ctx->Stencil.Ref = 0;
1296 ctx->Stencil.ValueMask = STENCIL_MAX;
1297 ctx->Stencil.Clear = 0;
1298 ctx->Stencil.WriteMask = STENCIL_MAX;
1299
1300 /* Texture group */
1301 ctx->Texture.CurrentUnit = 0; /* multitexture */
1302 ctx->Texture._ReallyEnabled = 0; /* XXX obsolete */
1303 ctx->Texture._EnabledUnits = 0;
1304 for (i=0; i<MAX_TEXTURE_UNITS; i++)
1305 init_texture_unit( ctx, i );
1306 ctx->Texture.SharedPalette = GL_FALSE;
1307 _mesa_init_colortable(&ctx->Texture.Palette);
1308
1309 /* Transformation group */
1310 ctx->Transform.MatrixMode = GL_MODELVIEW;
1311 ctx->Transform.Normalize = GL_FALSE;
1312 ctx->Transform.RescaleNormals = GL_FALSE;
1313 ctx->Transform.RasterPositionUnclipped = GL_FALSE;
1314 for (i=0;i<MAX_CLIP_PLANES;i++) {
1315 ASSIGN_4V( ctx->Transform.EyeUserPlane[i], 0.0, 0.0, 0.0, 0.0 );
1316 }
1317 ctx->Transform.ClipPlanesEnabled = 0;
1318
1319 /* Viewport group */
1320 ctx->Viewport.X = 0;
1321 ctx->Viewport.Y = 0;
1322 ctx->Viewport.Width = 0;
1323 ctx->Viewport.Height = 0;
1324 ctx->Viewport.Near = 0.0;
1325 ctx->Viewport.Far = 1.0;
1326 _math_matrix_ctr(&ctx->Viewport._WindowMap);
1327
1328 #define Sz 10
1329 #define Tz 14
1330 ctx->Viewport._WindowMap.m[Sz] = 0.5F * ctx->DepthMaxF;
1331 ctx->Viewport._WindowMap.m[Tz] = 0.5F * ctx->DepthMaxF;
1332 #undef Sz
1333 #undef Tz
1334
1335 ctx->Viewport._WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
1336 ctx->Viewport._WindowMap.type = MATRIX_3D_NO_ROT;
1337
1338 /* Vertex arrays */
1339 ctx->Array.Vertex.Size = 4;
1340 ctx->Array.Vertex.Type = GL_FLOAT;
1341 ctx->Array.Vertex.Stride = 0;
1342 ctx->Array.Vertex.StrideB = 0;
1343 ctx->Array.Vertex.Ptr = NULL;
1344 ctx->Array.Vertex.Enabled = GL_FALSE;
1345 ctx->Array.Vertex.Flags = CA_CLIENT_DATA;
1346 ctx->Array.Normal.Type = GL_FLOAT;
1347 ctx->Array.Normal.Stride = 0;
1348 ctx->Array.Normal.StrideB = 0;
1349 ctx->Array.Normal.Ptr = NULL;
1350 ctx->Array.Normal.Enabled = GL_FALSE;
1351 ctx->Array.Normal.Flags = CA_CLIENT_DATA;
1352 ctx->Array.Color.Size = 4;
1353 ctx->Array.Color.Type = GL_FLOAT;
1354 ctx->Array.Color.Stride = 0;
1355 ctx->Array.Color.StrideB = 0;
1356 ctx->Array.Color.Ptr = NULL;
1357 ctx->Array.Color.Enabled = GL_FALSE;
1358 ctx->Array.Color.Flags = CA_CLIENT_DATA;
1359 ctx->Array.SecondaryColor.Size = 4;
1360 ctx->Array.SecondaryColor.Type = GL_FLOAT;
1361 ctx->Array.SecondaryColor.Stride = 0;
1362 ctx->Array.SecondaryColor.StrideB = 0;
1363 ctx->Array.SecondaryColor.Ptr = NULL;
1364 ctx->Array.SecondaryColor.Enabled = GL_FALSE;
1365 ctx->Array.SecondaryColor.Flags = CA_CLIENT_DATA;
1366 ctx->Array.FogCoord.Size = 1;
1367 ctx->Array.FogCoord.Type = GL_FLOAT;
1368 ctx->Array.FogCoord.Stride = 0;
1369 ctx->Array.FogCoord.StrideB = 0;
1370 ctx->Array.FogCoord.Ptr = NULL;
1371 ctx->Array.FogCoord.Enabled = GL_FALSE;
1372 ctx->Array.FogCoord.Flags = CA_CLIENT_DATA;
1373 ctx->Array.Index.Type = GL_FLOAT;
1374 ctx->Array.Index.Stride = 0;
1375 ctx->Array.Index.StrideB = 0;
1376 ctx->Array.Index.Ptr = NULL;
1377 ctx->Array.Index.Enabled = GL_FALSE;
1378 ctx->Array.Index.Flags = CA_CLIENT_DATA;
1379 for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1380 ctx->Array.TexCoord[i].Size = 4;
1381 ctx->Array.TexCoord[i].Type = GL_FLOAT;
1382 ctx->Array.TexCoord[i].Stride = 0;
1383 ctx->Array.TexCoord[i].StrideB = 0;
1384 ctx->Array.TexCoord[i].Ptr = NULL;
1385 ctx->Array.TexCoord[i].Enabled = GL_FALSE;
1386 ctx->Array.TexCoord[i].Flags = CA_CLIENT_DATA;
1387 }
1388 ctx->Array.TexCoordInterleaveFactor = 1;
1389 ctx->Array.EdgeFlag.Stride = 0;
1390 ctx->Array.EdgeFlag.StrideB = 0;
1391 ctx->Array.EdgeFlag.Ptr = NULL;
1392 ctx->Array.EdgeFlag.Enabled = GL_FALSE;
1393 ctx->Array.EdgeFlag.Flags = CA_CLIENT_DATA;
1394 ctx->Array.ActiveTexture = 0; /* GL_ARB_multitexture */
1395
1396 /* Pixel transfer */
1397 ctx->Pack.Alignment = 4;
1398 ctx->Pack.RowLength = 0;
1399 ctx->Pack.ImageHeight = 0;
1400 ctx->Pack.SkipPixels = 0;
1401 ctx->Pack.SkipRows = 0;
1402 ctx->Pack.SkipImages = 0;
1403 ctx->Pack.SwapBytes = GL_FALSE;
1404 ctx->Pack.LsbFirst = GL_FALSE;
1405 ctx->Unpack.Alignment = 4;
1406 ctx->Unpack.RowLength = 0;
1407 ctx->Unpack.ImageHeight = 0;
1408 ctx->Unpack.SkipPixels = 0;
1409 ctx->Unpack.SkipRows = 0;
1410 ctx->Unpack.SkipImages = 0;
1411 ctx->Unpack.SwapBytes = GL_FALSE;
1412 ctx->Unpack.LsbFirst = GL_FALSE;
1413
1414 /* Feedback */
1415 ctx->Feedback.Type = GL_2D; /* TODO: verify */
1416 ctx->Feedback.Buffer = NULL;
1417 ctx->Feedback.BufferSize = 0;
1418 ctx->Feedback.Count = 0;
1419
1420 /* Selection/picking */
1421 ctx->Select.Buffer = NULL;
1422 ctx->Select.BufferSize = 0;
1423 ctx->Select.BufferCount = 0;
1424 ctx->Select.Hits = 0;
1425 ctx->Select.NameStackDepth = 0;
1426
1427 /* Renderer and client attribute stacks */
1428 ctx->AttribStackDepth = 0;
1429 ctx->ClientAttribStackDepth = 0;
1430
1431 /* Display list */
1432 ctx->CallDepth = 0;
1433 ctx->ExecuteFlag = GL_TRUE;
1434 ctx->CompileFlag = GL_FALSE;
1435 ctx->CurrentListPtr = NULL;
1436 ctx->CurrentBlock = NULL;
1437 ctx->CurrentListNum = 0;
1438 ctx->CurrentPos = 0;
1439
1440 /* Color tables */
1441 _mesa_init_colortable(&ctx->ColorTable);
1442 _mesa_init_colortable(&ctx->ProxyColorTable);
1443 _mesa_init_colortable(&ctx->PostConvolutionColorTable);
1444 _mesa_init_colortable(&ctx->ProxyPostConvolutionColorTable);
1445 _mesa_init_colortable(&ctx->PostColorMatrixColorTable);
1446 _mesa_init_colortable(&ctx->ProxyPostColorMatrixColorTable);
1447
1448 /* GL_NV_vertex_program */
1449 ctx->VertexProgram.Enabled = GL_FALSE;
1450 ctx->VertexProgram.PointSizeEnabled = GL_FALSE;
1451 ctx->VertexProgram.TwoSideEnabled = GL_FALSE;
1452 ctx->VertexProgram.CurrentID = 0;
1453 ctx->VertexProgram.ErrorPos = -1;
1454 ctx->VertexProgram.Current = NULL;
1455 for (i = 0; i < VP_NUM_PROG_REGS / 4; i++) {
1456 ctx->VertexProgram.TrackMatrix[i] = GL_NONE;
1457 ctx->VertexProgram.TrackMatrixTransform[i] = GL_IDENTITY_NV;
1458 }
1459
1460 /* Miscellaneous */
1461 ctx->NewState = _NEW_ALL;
1462 ctx->RenderMode = GL_RENDER;
1463 ctx->_ImageTransferState = 0;
1464
1465 ctx->_NeedNormals = 0;
1466 ctx->_NeedEyeCoords = 0;
1467 ctx->_ModelViewInvScale = 1.0;
1468
1469 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1470
1471 ctx->CatchSignals = GL_TRUE;
1472 ctx->OcclusionResult = GL_FALSE;
1473 ctx->OcclusionResultSaved = GL_FALSE;
1474
1475 /* For debug/development only */
1476 ctx->NoRaster = ctx->imports.getenv(ctx, "MESA_NO_RASTER") ? GL_TRUE : GL_FALSE;
1477 ctx->FirstTimeCurrent = GL_TRUE;
1478
1479 /* Dither disable */
1480 ctx->NoDither = ctx->imports.getenv(ctx, "MESA_NO_DITHER") ? GL_TRUE : GL_FALSE;
1481 if (ctx->NoDither) {
1482 if (ctx->imports.getenv(ctx, "MESA_DEBUG")) {
1483 fprintf(stderr, "MESA_NO_DITHER set - dithering disabled\n");
1484 }
1485 ctx->Color.DitherFlag = GL_FALSE;
1486 }
1487 }
1488
1489
1490
1491
1492 /*
1493 * Allocate the proxy textures. If we run out of memory part way through
1494 * the allocations clean up and return GL_FALSE.
1495 * Return: GL_TRUE=success, GL_FALSE=failure
1496 */
1497 static GLboolean
1498 alloc_proxy_textures( GLcontext *ctx )
1499 {
1500 GLboolean out_of_memory;
1501 GLint i;
1502
1503 ctx->Texture.Proxy1D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_1D);
1504 if (!ctx->Texture.Proxy1D) {
1505 return GL_FALSE;
1506 }
1507
1508 ctx->Texture.Proxy2D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_2D);
1509 if (!ctx->Texture.Proxy2D) {
1510 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1511 return GL_FALSE;
1512 }
1513
1514 ctx->Texture.Proxy3D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_3D);
1515 if (!ctx->Texture.Proxy3D) {
1516 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1517 _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
1518 return GL_FALSE;
1519 }
1520
1521 ctx->Texture.ProxyCubeMap = _mesa_alloc_texture_object(NULL, 0,
1522 GL_TEXTURE_CUBE_MAP_ARB);
1523 if (!ctx->Texture.ProxyCubeMap) {
1524 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1525 _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
1526 _mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
1527 return GL_FALSE;
1528 }
1529
1530 ctx->Texture.ProxyRect = _mesa_alloc_texture_object(NULL, 0,
1531 GL_TEXTURE_RECTANGLE_NV);
1532 if (!ctx->Texture.ProxyRect) {
1533 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1534 _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
1535 _mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
1536 _mesa_free_texture_object(NULL, ctx->Texture.ProxyCubeMap);
1537 return GL_FALSE;
1538 }
1539
1540 out_of_memory = GL_FALSE;
1541 for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1542 ctx->Texture.Proxy1D->Image[i] = _mesa_alloc_texture_image();
1543 ctx->Texture.Proxy2D->Image[i] = _mesa_alloc_texture_image();
1544 ctx->Texture.Proxy3D->Image[i] = _mesa_alloc_texture_image();
1545 ctx->Texture.ProxyCubeMap->Image[i] = _mesa_alloc_texture_image();
1546 if (!ctx->Texture.Proxy1D->Image[i]
1547 || !ctx->Texture.Proxy2D->Image[i]
1548 || !ctx->Texture.Proxy3D->Image[i]
1549 || !ctx->Texture.ProxyCubeMap->Image[i]) {
1550 out_of_memory = GL_TRUE;
1551 }
1552 }
1553 ctx->Texture.ProxyRect->Image[0] = _mesa_alloc_texture_image();
1554 if (!ctx->Texture.ProxyRect->Image[0])
1555 out_of_memory = GL_TRUE;
1556
1557 if (out_of_memory) {
1558 for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1559 if (ctx->Texture.Proxy1D->Image[i]) {
1560 _mesa_free_texture_image(ctx->Texture.Proxy1D->Image[i]);
1561 }
1562 if (ctx->Texture.Proxy2D->Image[i]) {
1563 _mesa_free_texture_image(ctx->Texture.Proxy2D->Image[i]);
1564 }
1565 if (ctx->Texture.Proxy3D->Image[i]) {
1566 _mesa_free_texture_image(ctx->Texture.Proxy3D->Image[i]);
1567 }
1568 if (ctx->Texture.ProxyCubeMap->Image[i]) {
1569 _mesa_free_texture_image(ctx->Texture.ProxyCubeMap->Image[i]);
1570 }
1571 }
1572 if (ctx->Texture.ProxyRect->Image[0]) {
1573 _mesa_free_texture_image(ctx->Texture.ProxyRect->Image[0]);
1574 }
1575 _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
1576 _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
1577 _mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
1578 _mesa_free_texture_object(NULL, ctx->Texture.ProxyCubeMap);
1579 _mesa_free_texture_object(NULL, ctx->Texture.ProxyRect);
1580 return GL_FALSE;
1581 }
1582 else {
1583 return GL_TRUE;
1584 }
1585 }
1586
1587
1588 static void add_debug_flags( const char *debug )
1589 {
1590 #ifdef MESA_DEBUG
1591 if (strstr(debug, "varray"))
1592 MESA_VERBOSE |= VERBOSE_VARRAY;
1593
1594 if (strstr(debug, "tex"))
1595 MESA_VERBOSE |= VERBOSE_TEXTURE;
1596
1597 if (strstr(debug, "imm"))
1598 MESA_VERBOSE |= VERBOSE_IMMEDIATE;
1599
1600 if (strstr(debug, "pipe"))
1601 MESA_VERBOSE |= VERBOSE_PIPELINE;
1602
1603 if (strstr(debug, "driver"))
1604 MESA_VERBOSE |= VERBOSE_DRIVER;
1605
1606 if (strstr(debug, "state"))
1607 MESA_VERBOSE |= VERBOSE_STATE;
1608
1609 if (strstr(debug, "api"))
1610 MESA_VERBOSE |= VERBOSE_API;
1611
1612 if (strstr(debug, "list"))
1613 MESA_VERBOSE |= VERBOSE_DISPLAY_LIST;
1614
1615 if (strstr(debug, "lighting"))
1616 MESA_VERBOSE |= VERBOSE_LIGHTING;
1617
1618 /* Debug flag:
1619 */
1620 if (strstr(debug, "flush"))
1621 MESA_DEBUG_FLAGS |= DEBUG_ALWAYS_FLUSH;
1622 #endif
1623 }
1624
1625
1626 /*
1627 * Initialize a GLcontext struct. This includes allocating all the
1628 * other structs and arrays which hang off of the context by pointers.
1629 */
1630 GLboolean
1631 _mesa_initialize_context( GLcontext *ctx,
1632 const GLvisual *visual,
1633 GLcontext *share_list,
1634 const __GLimports *imports )
1635 {
1636 GLuint dispatchSize;
1637
1638 ASSERT(imports);
1639 ASSERT(imports->other); /* other points to the device driver's context */
1640
1641 /* assing imports */
1642 ctx->imports = *imports;
1643
1644 /* initialize the exports (Mesa functions called by the window system) */
1645 _mesa_init_default_exports( &(ctx->exports) );
1646
1647 /* misc one-time initializations */
1648 one_time_init(ctx);
1649
1650 #if 0
1651 /**
1652 ** OpenGL SI stuff
1653 **/
1654 if (!ctx->imports.malloc) {
1655 _mesa_init_default_imports(&ctx->imports, driver_ctx);
1656 }
1657 /* exports are setup by the device driver */
1658 #endif
1659
1660 ctx->DriverCtx = imports->other;
1661 ctx->Visual = *visual;
1662 ctx->DrawBuffer = NULL;
1663 ctx->ReadBuffer = NULL;
1664
1665 if (share_list) {
1666 /* share state with another context */
1667 ctx->Shared = share_list->Shared;
1668 }
1669 else {
1670 /* allocate new, unshared state */
1671 ctx->Shared = alloc_shared_state();
1672 if (!ctx->Shared) {
1673 return GL_FALSE;
1674 }
1675 }
1676 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1677 ctx->Shared->RefCount++;
1678 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1679
1680 /* Effectively bind the default textures to all texture units */
1681 ctx->Shared->Default1D->RefCount += MAX_TEXTURE_UNITS;
1682 ctx->Shared->Default2D->RefCount += MAX_TEXTURE_UNITS;
1683 ctx->Shared->Default3D->RefCount += MAX_TEXTURE_UNITS;
1684 ctx->Shared->DefaultCubeMap->RefCount += MAX_TEXTURE_UNITS;
1685 ctx->Shared->DefaultRect->RefCount += MAX_TEXTURE_UNITS;
1686
1687 init_attrib_groups( ctx );
1688
1689 if (visual->doubleBufferMode) {
1690 ctx->Color.DrawBuffer = GL_BACK;
1691 ctx->Color.DriverDrawBuffer = GL_BACK_LEFT;
1692 ctx->Color.DrawDestMask = BACK_LEFT_BIT;
1693 ctx->Pixel.ReadBuffer = GL_BACK;
1694 ctx->Pixel.DriverReadBuffer = GL_BACK_LEFT;
1695 }
1696 else {
1697 ctx->Color.DrawBuffer = GL_FRONT;
1698 ctx->Color.DriverDrawBuffer = GL_FRONT_LEFT;
1699 ctx->Color.DrawDestMask = FRONT_LEFT_BIT;
1700 ctx->Pixel.ReadBuffer = GL_FRONT;
1701 ctx->Pixel.DriverReadBuffer = GL_FRONT_LEFT;
1702 }
1703
1704 if (!alloc_proxy_textures(ctx)) {
1705 free_shared_state(ctx, ctx->Shared);
1706 return GL_FALSE;
1707 }
1708
1709 /* register the most recent extension functions with libGL */
1710 _glapi_add_entrypoint("glTbufferMask3DFX", 553);
1711 _glapi_add_entrypoint("glCompressedTexImage3DARB", 554);
1712 _glapi_add_entrypoint("glCompressedTexImage2DARB", 555);
1713 _glapi_add_entrypoint("glCompressedTexImage1DARB", 556);
1714 _glapi_add_entrypoint("glCompressedTexSubImage3DARB", 557);
1715 _glapi_add_entrypoint("glCompressedTexSubImage2DARB", 558);
1716 _glapi_add_entrypoint("glCompressedTexSubImage1DARB", 559);
1717 _glapi_add_entrypoint("glGetCompressedTexImageARB", 560);
1718
1719 /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1720 * In practice, this'll be the same for stand-alone Mesa. But for DRI
1721 * Mesa we do this to accomodate different versions of libGL and various
1722 * DRI drivers.
1723 */
1724 dispatchSize = MAX2(_glapi_get_dispatch_table_size(),
1725 sizeof(struct _glapi_table) / sizeof(void *));
1726
1727 /* setup API dispatch tables */
1728 ctx->Exec = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
1729 ctx->Save = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
1730 if (!ctx->Exec || !ctx->Save) {
1731 free_shared_state(ctx, ctx->Shared);
1732 if (ctx->Exec)
1733 FREE( ctx->Exec );
1734 }
1735 _mesa_init_exec_table(ctx->Exec, dispatchSize);
1736 _mesa_init_dlist_table(ctx->Save, dispatchSize);
1737 ctx->CurrentDispatch = ctx->Exec;
1738
1739 ctx->ExecPrefersFloat = GL_FALSE;
1740 ctx->SavePrefersFloat = GL_FALSE;
1741
1742 /* Neutral tnl module stuff */
1743 _mesa_init_exec_vtxfmt( ctx );
1744 ctx->TnlModule.Current = NULL;
1745 ctx->TnlModule.SwapCount = 0;
1746
1747 /* Z buffer stuff */
1748 if (ctx->Visual.depthBits == 0) {
1749 /* Special case. Even if we don't have a depth buffer we need
1750 * good values for DepthMax for Z vertex transformation purposes
1751 * and for per-fragment fog computation.
1752 */
1753 ctx->DepthMax = 1 << 16;
1754 ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
1755 }
1756 else if (ctx->Visual.depthBits < 32) {
1757 ctx->DepthMax = (1 << ctx->Visual.depthBits) - 1;
1758 ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
1759 }
1760 else {
1761 /* Special case since shift values greater than or equal to the
1762 * number of bits in the left hand expression's type are undefined.
1763 */
1764 ctx->DepthMax = 0xffffffff;
1765 ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
1766 }
1767 ctx->MRD = 1.0; /* Minimum resolvable depth value, for polygon offset */
1768
1769
1770 #if defined(MESA_TRACE)
1771 ctx->TraceCtx = (trace_context_t *) CALLOC( sizeof(trace_context_t) );
1772 #if 0
1773 /* Brian: do you want to have CreateContext fail here,
1774 or should we just trap in NewTrace (currently done)? */
1775 if (!(ctx->TraceCtx)) {
1776 free_shared_state(ctx, ctx->Shared);
1777 FREE( ctx->Exec );
1778 FREE( ctx->Save );
1779 return GL_FALSE;
1780 }
1781 #endif
1782 trInitContext(ctx->TraceCtx);
1783
1784 ctx->TraceDispatch = (struct _glapi_table *)
1785 CALLOC(dispatchSize * sizeof(void*));
1786 #if 0
1787 if (!(ctx->TraceCtx)) {
1788 free_shared_state(ctx, ctx->Shared);
1789 FREE( ctx->Exec );
1790 FREE( ctx->Save );
1791 FREE( ctx->TraceCtx );
1792 return GL_FALSE;
1793 }
1794 #endif
1795 trInitDispatch(ctx->TraceDispatch);
1796 #endif
1797
1798
1799 if (ctx->imports.getenv(ctx, "MESA_DEBUG"))
1800 add_debug_flags(ctx->imports.getenv(ctx, "MESA_DEBUG"));
1801
1802 if (ctx->imports.getenv(ctx, "MESA_VERBOSE"))
1803 add_debug_flags(ctx->imports.getenv(ctx, "MESA_VERBOSE"));
1804
1805 return GL_TRUE;
1806 }
1807
1808
1809
1810 /*
1811 * Allocate and initialize a GLcontext structure.
1812 * Input: visual - a GLvisual pointer (we copy the struct contents)
1813 * sharelist - another context to share display lists with or NULL
1814 * imports - points to a fully-initialized __GLimports object.
1815 * Return: pointer to a new __GLcontextRec or NULL if error.
1816 */
1817 GLcontext *
1818 _mesa_create_context( const GLvisual *visual,
1819 GLcontext *share_list,
1820 const __GLimports *imports )
1821 {
1822 GLcontext *ctx;
1823
1824 ASSERT(visual);
1825 ASSERT(imports);
1826 ASSERT(imports->calloc);
1827
1828 ctx = (GLcontext *) imports->calloc(NULL, 1, sizeof(GLcontext));
1829 if (!ctx)
1830 return NULL;
1831
1832 ctx->Driver.CurrentExecPrimitive = 0; /* XXX why is this here??? */
1833
1834 if (_mesa_initialize_context(ctx, visual, share_list, imports)) {
1835 return ctx;
1836 }
1837 else {
1838 imports->free(NULL, ctx);
1839 return NULL;
1840 }
1841 }
1842
1843
1844
1845 /*
1846 * Free the data associated with the given context.
1847 * But don't free() the GLcontext struct itself!
1848 */
1849 void
1850 _mesa_free_context_data( GLcontext *ctx )
1851 {
1852 struct gl_shine_tab *s, *tmps;
1853 GLuint i;
1854
1855 /* if we're destroying the current context, unbind it first */
1856 if (ctx == _mesa_get_current_context()) {
1857 _mesa_make_current(NULL, NULL);
1858 }
1859
1860 /*
1861 * Free transformation matrix stacks
1862 */
1863 free_matrix_stack(&ctx->ModelviewMatrixStack);
1864 free_matrix_stack(&ctx->ProjectionMatrixStack);
1865 free_matrix_stack(&ctx->ColorMatrixStack);
1866 for (i = 0; i < MAX_TEXTURE_UNITS; i++)
1867 free_matrix_stack(&ctx->TextureMatrixStack[i]);
1868 for (i = 0; i < MAX_PROGRAM_MATRICES; i++)
1869 free_matrix_stack(&ctx->ProgramMatrixStack[i]);
1870 /* combined Modelview*Projection matrix */
1871 _math_matrix_dtr( &ctx->_ModelProjectMatrix );
1872
1873
1874 if (ctx->VertexProgram.Current) {
1875 ctx->VertexProgram.Current->RefCount--;
1876 if (ctx->VertexProgram.Current->RefCount <= 0)
1877 _mesa_delete_program(ctx, ctx->VertexProgram.CurrentID);
1878 }
1879
1880 /* Shared context state (display lists, textures, etc) */
1881 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1882 ctx->Shared->RefCount--;
1883 assert(ctx->Shared->RefCount >= 0);
1884 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1885 if (ctx->Shared->RefCount == 0) {
1886 /* free shared state */
1887 free_shared_state( ctx, ctx->Shared );
1888 }
1889
1890 /* Free lighting shininess exponentiation table */
1891 foreach_s( s, tmps, ctx->_ShineTabList ) {
1892 FREE( s );
1893 }
1894 FREE( ctx->_ShineTabList );
1895
1896 /* Free proxy texture objects */
1897 _mesa_free_texture_object( NULL, ctx->Texture.Proxy1D );
1898 _mesa_free_texture_object( NULL, ctx->Texture.Proxy2D );
1899 _mesa_free_texture_object( NULL, ctx->Texture.Proxy3D );
1900 _mesa_free_texture_object( NULL, ctx->Texture.ProxyCubeMap );
1901 _mesa_free_texture_object( NULL, ctx->Texture.ProxyRect );
1902
1903 /* Free evaluator data */
1904 if (ctx->EvalMap.Map1Vertex3.Points)
1905 FREE( ctx->EvalMap.Map1Vertex3.Points );
1906 if (ctx->EvalMap.Map1Vertex4.Points)
1907 FREE( ctx->EvalMap.Map1Vertex4.Points );
1908 if (ctx->EvalMap.Map1Index.Points)
1909 FREE( ctx->EvalMap.Map1Index.Points );
1910 if (ctx->EvalMap.Map1Color4.Points)
1911 FREE( ctx->EvalMap.Map1Color4.Points );
1912 if (ctx->EvalMap.Map1Normal.Points)
1913 FREE( ctx->EvalMap.Map1Normal.Points );
1914 if (ctx->EvalMap.Map1Texture1.Points)
1915 FREE( ctx->EvalMap.Map1Texture1.Points );
1916 if (ctx->EvalMap.Map1Texture2.Points)
1917 FREE( ctx->EvalMap.Map1Texture2.Points );
1918 if (ctx->EvalMap.Map1Texture3.Points)
1919 FREE( ctx->EvalMap.Map1Texture3.Points );
1920 if (ctx->EvalMap.Map1Texture4.Points)
1921 FREE( ctx->EvalMap.Map1Texture4.Points );
1922 for (i = 0; i < 16; i++)
1923 FREE((ctx->EvalMap.Map1Attrib[i].Points));
1924
1925 if (ctx->EvalMap.Map2Vertex3.Points)
1926 FREE( ctx->EvalMap.Map2Vertex3.Points );
1927 if (ctx->EvalMap.Map2Vertex4.Points)
1928 FREE( ctx->EvalMap.Map2Vertex4.Points );
1929 if (ctx->EvalMap.Map2Index.Points)
1930 FREE( ctx->EvalMap.Map2Index.Points );
1931 if (ctx->EvalMap.Map2Color4.Points)
1932 FREE( ctx->EvalMap.Map2Color4.Points );
1933 if (ctx->EvalMap.Map2Normal.Points)
1934 FREE( ctx->EvalMap.Map2Normal.Points );
1935 if (ctx->EvalMap.Map2Texture1.Points)
1936 FREE( ctx->EvalMap.Map2Texture1.Points );
1937 if (ctx->EvalMap.Map2Texture2.Points)
1938 FREE( ctx->EvalMap.Map2Texture2.Points );
1939 if (ctx->EvalMap.Map2Texture3.Points)
1940 FREE( ctx->EvalMap.Map2Texture3.Points );
1941 if (ctx->EvalMap.Map2Texture4.Points)
1942 FREE( ctx->EvalMap.Map2Texture4.Points );
1943 for (i = 0; i < 16; i++)
1944 FREE((ctx->EvalMap.Map2Attrib[i].Points));
1945
1946 _mesa_free_colortable_data( &ctx->ColorTable );
1947 _mesa_free_colortable_data( &ctx->PostConvolutionColorTable );
1948 _mesa_free_colortable_data( &ctx->PostColorMatrixColorTable );
1949 _mesa_free_colortable_data( &ctx->Texture.Palette );
1950
1951 _math_matrix_dtr(&ctx->Viewport._WindowMap);
1952
1953 _mesa_extensions_dtr(ctx);
1954
1955 FREE(ctx->Exec);
1956 FREE(ctx->Save);
1957 }
1958
1959
1960
1961 /*
1962 * Destroy a GLcontext structure.
1963 */
1964 void
1965 _mesa_destroy_context( GLcontext *ctx )
1966 {
1967 if (ctx) {
1968 _mesa_free_context_data(ctx);
1969 FREE( (void *) ctx );
1970 }
1971 }
1972
1973
1974
1975 /*
1976 * Copy attribute groups from one context to another.
1977 * Input: src - source context
1978 * dst - destination context
1979 * mask - bitwise OR of GL_*_BIT flags
1980 */
1981 void
1982 _mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1983 {
1984 if (mask & GL_ACCUM_BUFFER_BIT) {
1985 /* OK to memcpy */
1986 dst->Accum = src->Accum;
1987 }
1988 if (mask & GL_COLOR_BUFFER_BIT) {
1989 /* OK to memcpy */
1990 dst->Color = src->Color;
1991 }
1992 if (mask & GL_CURRENT_BIT) {
1993 /* OK to memcpy */
1994 dst->Current = src->Current;
1995 }
1996 if (mask & GL_DEPTH_BUFFER_BIT) {
1997 /* OK to memcpy */
1998 dst->Depth = src->Depth;
1999 }
2000 if (mask & GL_ENABLE_BIT) {
2001 /* no op */
2002 }
2003 if (mask & GL_EVAL_BIT) {
2004 /* OK to memcpy */
2005 dst->Eval = src->Eval;
2006 }
2007 if (mask & GL_FOG_BIT) {
2008 /* OK to memcpy */
2009 dst->Fog = src->Fog;
2010 }
2011 if (mask & GL_HINT_BIT) {
2012 /* OK to memcpy */
2013 dst->Hint = src->Hint;
2014 }
2015 if (mask & GL_LIGHTING_BIT) {
2016 GLuint i;
2017 /* begin with memcpy */
2018 MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light) );
2019 /* fixup linked lists to prevent pointer insanity */
2020 make_empty_list( &(dst->Light.EnabledList) );
2021 for (i = 0; i < MAX_LIGHTS; i++) {
2022 if (dst->Light.Light[i].Enabled) {
2023 insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
2024 }
2025 }
2026 }
2027 if (mask & GL_LINE_BIT) {
2028 /* OK to memcpy */
2029 dst->Line = src->Line;
2030 }
2031 if (mask & GL_LIST_BIT) {
2032 /* OK to memcpy */
2033 dst->List = src->List;
2034 }
2035 if (mask & GL_PIXEL_MODE_BIT) {
2036 /* OK to memcpy */
2037 dst->Pixel = src->Pixel;
2038 }
2039 if (mask & GL_POINT_BIT) {
2040 /* OK to memcpy */
2041 dst->Point = src->Point;
2042 }
2043 if (mask & GL_POLYGON_BIT) {
2044 /* OK to memcpy */
2045 dst->Polygon = src->Polygon;
2046 }
2047 if (mask & GL_POLYGON_STIPPLE_BIT) {
2048 /* Use loop instead of MEMCPY due to problem with Portland Group's
2049 * C compiler. Reported by John Stone.
2050 */
2051 GLuint i;
2052 for (i = 0; i < 32; i++) {
2053 dst->PolygonStipple[i] = src->PolygonStipple[i];
2054 }
2055 }
2056 if (mask & GL_SCISSOR_BIT) {
2057 /* OK to memcpy */
2058 dst->Scissor = src->Scissor;
2059 }
2060 if (mask & GL_STENCIL_BUFFER_BIT) {
2061 /* OK to memcpy */
2062 dst->Stencil = src->Stencil;
2063 }
2064 if (mask & GL_TEXTURE_BIT) {
2065 /* Cannot memcpy because of pointers */
2066 _mesa_copy_texture_state(src, dst);
2067 }
2068 if (mask & GL_TRANSFORM_BIT) {
2069 /* OK to memcpy */
2070 dst->Transform = src->Transform;
2071 }
2072 if (mask & GL_VIEWPORT_BIT) {
2073 /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
2074 dst->Viewport.X = src->Viewport.X;
2075 dst->Viewport.Y = src->Viewport.Y;
2076 dst->Viewport.Width = src->Viewport.Width;
2077 dst->Viewport.Height = src->Viewport.Height;
2078 dst->Viewport.Near = src->Viewport.Near;
2079 dst->Viewport.Far = src->Viewport.Far;
2080 _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
2081 }
2082
2083 /* XXX FIXME: Call callbacks?
2084 */
2085 dst->NewState = _NEW_ALL;
2086 }
2087
2088
2089
2090 static void print_info( void )
2091 {
2092 fprintf(stderr, "Mesa GL_VERSION = %s\n",
2093 (char *) _mesa_GetString(GL_VERSION));
2094 fprintf(stderr, "Mesa GL_RENDERER = %s\n",
2095 (char *) _mesa_GetString(GL_RENDERER));
2096 fprintf(stderr, "Mesa GL_VENDOR = %s\n",
2097 (char *) _mesa_GetString(GL_VENDOR));
2098 fprintf(stderr, "Mesa GL_EXTENSIONS = %s\n",
2099 (char *) _mesa_GetString(GL_EXTENSIONS));
2100 #if defined(THREADS)
2101 fprintf(stderr, "Mesa thread-safe: YES\n");
2102 #else
2103 fprintf(stderr, "Mesa thread-safe: NO\n");
2104 #endif
2105 #if defined(USE_X86_ASM)
2106 fprintf(stderr, "Mesa x86-optimized: YES\n");
2107 #else
2108 fprintf(stderr, "Mesa x86-optimized: NO\n");
2109 #endif
2110 #if defined(USE_SPARC_ASM)
2111 fprintf(stderr, "Mesa sparc-optimized: YES\n");
2112 #else
2113 fprintf(stderr, "Mesa sparc-optimized: NO\n");
2114 #endif
2115 }
2116
2117
2118 /*
2119 * Set the current context, binding the given frame buffer to the context.
2120 */
2121 void
2122 _mesa_make_current( GLcontext *newCtx, GLframebuffer *buffer )
2123 {
2124 _mesa_make_current2( newCtx, buffer, buffer );
2125 }
2126
2127
2128 /*
2129 * Bind the given context to the given draw-buffer and read-buffer
2130 * and make it the current context for this thread.
2131 */
2132 void
2133 _mesa_make_current2( GLcontext *newCtx, GLframebuffer *drawBuffer,
2134 GLframebuffer *readBuffer )
2135 {
2136 if (MESA_VERBOSE)
2137 _mesa_debug(newCtx, "_mesa_make_current2()\n");
2138
2139 /* Check that the context's and framebuffer's visuals are compatible.
2140 * We could do a lot more checking here but this'll catch obvious
2141 * problems.
2142 */
2143 if (newCtx && drawBuffer && readBuffer) {
2144 if (newCtx->Visual.rgbMode != drawBuffer->Visual.rgbMode ||
2145 newCtx->Visual.redBits != drawBuffer->Visual.redBits ||
2146 newCtx->Visual.depthBits != drawBuffer->Visual.depthBits ||
2147 newCtx->Visual.stencilBits != drawBuffer->Visual.stencilBits ||
2148 newCtx->Visual.accumRedBits != drawBuffer->Visual.accumRedBits) {
2149 return; /* incompatible */
2150 }
2151 }
2152
2153 /* We call this function periodically (just here for now) in
2154 * order to detect when multithreading has begun.
2155 */
2156 _glapi_check_multithread();
2157
2158 _glapi_set_context((void *) newCtx);
2159 ASSERT(_mesa_get_current_context() == newCtx);
2160
2161
2162 if (!newCtx) {
2163 _glapi_set_dispatch(NULL); /* none current */
2164 }
2165 else {
2166 _glapi_set_dispatch(newCtx->CurrentDispatch);
2167
2168 if (drawBuffer && readBuffer) {
2169 /* TODO: check if newCtx and buffer's visual match??? */
2170 newCtx->DrawBuffer = drawBuffer;
2171 newCtx->ReadBuffer = readBuffer;
2172 newCtx->NewState |= _NEW_BUFFERS;
2173
2174 if (drawBuffer->Width == 0 && drawBuffer->Height == 0) {
2175 /* get initial window size */
2176 GLuint bufWidth, bufHeight;
2177
2178 /* ask device driver for size of output buffer */
2179 (*newCtx->Driver.GetBufferSize)( drawBuffer, &bufWidth, &bufHeight );
2180
2181 if (drawBuffer->Width == bufWidth && drawBuffer->Height == bufHeight)
2182 return; /* size is as expected */
2183
2184 drawBuffer->Width = bufWidth;
2185 drawBuffer->Height = bufHeight;
2186
2187 newCtx->Driver.ResizeBuffers( drawBuffer );
2188 }
2189
2190 if (readBuffer != drawBuffer &&
2191 readBuffer->Width == 0 && readBuffer->Height == 0) {
2192 /* get initial window size */
2193 GLuint bufWidth, bufHeight;
2194
2195 /* ask device driver for size of output buffer */
2196 (*newCtx->Driver.GetBufferSize)( readBuffer, &bufWidth, &bufHeight );
2197
2198 if (readBuffer->Width == bufWidth && readBuffer->Height == bufHeight)
2199 return; /* size is as expected */
2200
2201 readBuffer->Width = bufWidth;
2202 readBuffer->Height = bufHeight;
2203
2204 newCtx->Driver.ResizeBuffers( readBuffer );
2205 }
2206 }
2207
2208 /* This is only for T&L - a bit out of place, or misnamed (BP) */
2209 if (newCtx->Driver.MakeCurrent)
2210 newCtx->Driver.MakeCurrent( newCtx, drawBuffer, readBuffer );
2211
2212 /* We can use this to help debug user's problems. Tell them to set
2213 * the MESA_INFO env variable before running their app. Then the
2214 * first time each context is made current we'll print some useful
2215 * information.
2216 */
2217 if (newCtx->FirstTimeCurrent) {
2218 if (newCtx->imports.getenv(newCtx, "MESA_INFO")) {
2219 print_info();
2220 }
2221 newCtx->FirstTimeCurrent = GL_FALSE;
2222 }
2223 }
2224 }
2225
2226
2227
2228 /*
2229 * Return current context handle for the calling thread.
2230 * This isn't the fastest way to get the current context.
2231 * If you need speed, see the GET_CURRENT_CONTEXT() macro in context.h
2232 */
2233 GLcontext *
2234 _mesa_get_current_context( void )
2235 {
2236 return (GLcontext *) _glapi_get_context();
2237 }
2238
2239
2240
2241 /*
2242 * This should be called by device drivers just before they do a
2243 * swapbuffers. Any pending rendering commands will be executed.
2244 * XXX we should really rename this function to _mesa_flush() or something.
2245 */
2246 void
2247 _mesa_swapbuffers(GLcontext *ctx)
2248 {
2249 FLUSH_VERTICES( ctx, 0 );
2250 }
2251
2252
2253
2254 /*
2255 * Return pointer to this context's current API dispatch table.
2256 * It'll either be the immediate-mode execute dispatcher or the
2257 * display list compile dispatcher.
2258 */
2259 struct _glapi_table *
2260 _mesa_get_dispatch(GLcontext *ctx)
2261 {
2262 return ctx->CurrentDispatch;
2263 }
2264
2265
2266
2267 /**********************************************************************/
2268 /***** Miscellaneous functions *****/
2269 /**********************************************************************/
2270
2271
2272 /*
2273 * This function is called when the Mesa user has stumbled into a code
2274 * path which may not be implemented fully or correctly.
2275 */
2276 void _mesa_problem( const GLcontext *ctx, const char *s )
2277 {
2278 if (ctx) {
2279 ctx->imports.fprintf((GLcontext *) ctx, stderr, "Mesa implementation error: %s\n", s);
2280 #ifdef XF86DRI
2281 ctx->imports.fprintf((GLcontext *) ctx, stderr, "Please report to the DRI bug database at dri.sourceforge.net\n");
2282 #else
2283 ctx->imports.fprintf((GLcontext *) ctx, stderr, "Please report to the Mesa bug database at www.mesa3d.org\n" );
2284 #endif
2285 }
2286 else {
2287 /* what can we do if we don't have a context???? */
2288 fprintf( stderr, "Mesa implementation error: %s\n", s );
2289 #ifdef XF86DRI
2290 fprintf( stderr, "Please report to the DRI bug database at dri.sourceforge.net\n");
2291 #else
2292 fprintf( stderr, "Please report to the Mesa bug database at www.mesa3d.org\n" );
2293 #endif
2294 }
2295 }
2296
2297
2298
2299 /*
2300 * This is called to inform the user that he or she has tried to do
2301 * something illogical or if there's likely a bug in their program
2302 * (like enabled depth testing without a depth buffer).
2303 */
2304 void
2305 _mesa_warning( const GLcontext *ctx, const char *s )
2306 {
2307 (*ctx->imports.warning)((__GLcontext *) ctx, (char *) s);
2308 }
2309
2310
2311
2312 /*
2313 * This is Mesa's error handler. Normally, all that's done is the updating
2314 * of the current error value. If Mesa is compiled with -DDEBUG or if the
2315 * environment variable "MESA_DEBUG" is defined then a real error message
2316 * is printed to stderr.
2317 * Input: ctx - the GL context
2318 * error - the error value
2319 * where - usually the name of function where error was detected
2320 */
2321 void
2322 _mesa_error( GLcontext *ctx, GLenum error, const char *where )
2323 {
2324 const char *debugEnv;
2325 GLboolean debug;
2326
2327 if (ctx)
2328 debugEnv = ctx->imports.getenv(ctx, "MESA_DEBUG");
2329 else
2330 /* what can we do??? */
2331 debugEnv = "";
2332
2333 #ifdef DEBUG
2334 if (debugEnv && strstr(debugEnv, "silent"))
2335 debug = GL_FALSE;
2336 else
2337 debug = GL_TRUE;
2338 #else
2339 if (debugEnv)
2340 debug = GL_TRUE;
2341 else
2342 debug = GL_FALSE;
2343 #endif
2344
2345 if (debug) {
2346 const char *errstr;
2347 switch (error) {
2348 case GL_NO_ERROR:
2349 errstr = "GL_NO_ERROR";
2350 break;
2351 case GL_INVALID_VALUE:
2352 errstr = "GL_INVALID_VALUE";
2353 break;
2354 case GL_INVALID_ENUM:
2355 errstr = "GL_INVALID_ENUM";
2356 break;
2357 case GL_INVALID_OPERATION:
2358 errstr = "GL_INVALID_OPERATION";
2359 break;
2360 case GL_STACK_OVERFLOW:
2361 errstr = "GL_STACK_OVERFLOW";
2362 break;
2363 case GL_STACK_UNDERFLOW:
2364 errstr = "GL_STACK_UNDERFLOW";
2365 break;
2366 case GL_OUT_OF_MEMORY:
2367 errstr = "GL_OUT_OF_MEMORY";
2368 break;
2369 case GL_TABLE_TOO_LARGE:
2370 errstr = "GL_TABLE_TOO_LARGE";
2371 break;
2372 default:
2373 errstr = "unknown";
2374 break;
2375 }
2376 fprintf(stderr, "Mesa user error: %s in %s\n", errstr, where);
2377 }
2378
2379 if (!ctx)
2380 return;
2381
2382 if (ctx->ErrorValue == GL_NO_ERROR) {
2383 ctx->ErrorValue = error;
2384 }
2385
2386 /* Call device driver's error handler, if any. This is used on the Mac. */
2387 if (ctx->Driver.Error) {
2388 (*ctx->Driver.Error)( ctx );
2389 }
2390 }
2391
2392
2393 /*
2394 * Call this to report debug information. Uses stderr.
2395 */
2396 void
2397 _mesa_debug( const GLcontext *ctx, const char *fmtString, ... )
2398 {
2399 va_list args;
2400 va_start( args, fmtString );
2401 (void) ctx->imports.fprintf( (__GLcontext *) ctx, stderr, fmtString, args );
2402 va_end( args );
2403 }
2404
2405
2406 /*
2407 * A wrapper for printf. Uses stdout.
2408 */
2409 void
2410 _mesa_printf( const GLcontext *ctx, const char *fmtString, ... )
2411 {
2412 va_list args;
2413 va_start( args, fmtString );
2414 (void) ctx->imports.fprintf( (__GLcontext *) ctx, stdout, fmtString, args );
2415 va_end( args );
2416 }
2417
2418
2419
2420 void
2421 _mesa_Finish( void )
2422 {
2423 GET_CURRENT_CONTEXT(ctx);
2424 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
2425 if (ctx->Driver.Finish) {
2426 (*ctx->Driver.Finish)( ctx );
2427 }
2428 }
2429
2430
2431
2432 void
2433 _mesa_Flush( void )
2434 {
2435 GET_CURRENT_CONTEXT(ctx);
2436 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
2437 if (ctx->Driver.Flush) {
2438 (*ctx->Driver.Flush)( ctx );
2439 }
2440 }
2441
2442
2443
2444 const char *_mesa_prim_name[GL_POLYGON+4] = {
2445 "GL_POINTS",
2446 "GL_LINES",
2447 "GL_LINE_LOOP",
2448 "GL_LINE_STRIP",
2449 "GL_TRIANGLES",
2450 "GL_TRIANGLE_STRIP",
2451 "GL_TRIANGLE_FAN",
2452 "GL_QUADS",
2453 "GL_QUAD_STRIP",
2454 "GL_POLYGON",
2455 "outside begin/end",
2456 "inside unkown primitive",
2457 "unknown state"
2458 };