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