src/mesa/main/context.c

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