Subversion Repositories shark

Rev

Rev 72 | Details | Compare with Previous | Last modification | View Log | RSS feed

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