src/mesa/main/context.c

   1 /* $Id: context.c,v 1.87 2000/09/15 19:45:40 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.5
   6  *
   7  * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27
  28 #ifdef PC_HEADER
  29 #include "all.h"
  30 #else
  31 #include "glheader.h"
  32 #include "accum.h"
  33 #include "alphabuf.h"
  34 #include "clip.h"
  35 #include "colortab.h"
  36 #include "context.h"
  37 #include "cva.h"
  38 #include "depth.h"
  39 #include "dlist.h"
  40 #include "eval.h"
  41 #include "enums.h"
  42 #include "extensions.h"
  43 #include "fog.h"
  44 #include "get.h"
  45 #include "glapi.h"
  46 #include "glapinoop.h"
  47 #include "glthread.h"
  48 #include "hash.h"
  49 #include "light.h"
  50 #include "macros.h"
  51 #include "matrix.h"
  52 #include "mem.h"
  53 #include "mmath.h"
  54 #include "pb.h"
  55 #include "pipeline.h"
  56 #include "shade.h"
  57 #include "simple_list.h"
  58 #include "stencil.h"
  59 #include "stages.h"
  60 #include "state.h"
  61 #include "translate.h"
  62 #include "teximage.h"
  63 #include "texobj.h"
  64 #include "texstate.h"
  65 #include "texture.h"
  66 #include "types.h"
  67 #include "varray.h"
  68 #include "vb.h"
  69 #include "vbcull.h"
  70 #include "vbrender.h"
  71 #include "vbxform.h"
  72 #include "vertices.h"
  73 #include "xform.h"
  74 #endif
  75
  76
  77 #if defined(GL_MESA_TRACE)
  78 #include "Trace/tr_context.h"
  79 #include "Trace/tr_wrapper.h"
  80 #endif
  81
  82
  83 /**********************************************************************/
  84 /*****                  Context and Thread management             *****/
  85 /**********************************************************************/
  86
  87
  88 #if !defined(THREADS)
  89
  90 struct immediate *_mesa_CurrentInput = NULL;
  91
  92 #endif
  93
  94
  95 /**********************************************************************/
  96 /***** GL Visual allocation/destruction                           *****/
  97 /**********************************************************************/
  98
  99
 100 /*
 101  * Allocate a new GLvisual object.
 102  * Input:  rgbFlag - GL_TRUE=RGB(A) mode, GL_FALSE=Color Index mode
 103  *         dbFlag - double buffering?
 104  *         stereoFlag - stereo buffer?
 105  *         depthBits - requested bits per depth buffer value
 106  *                     Any value in [0, 32] is acceptable but the actual
 107  *                     depth type will be GLushort or GLuint as needed.
 108  *         stencilBits - requested minimum bits per stencil buffer value
 109  *         accumBits - requested minimum bits per accum buffer component
 110  *         indexBits - number of bits per pixel if rgbFlag==GL_FALSE
 111  *         red/green/blue/alphaBits - number of bits per color component
 112  *                                    in frame buffer for RGB(A) mode.
 113  *                                    We always use 8 in core Mesa though.
 114  * Return:  pointer to new GLvisual or NULL if requested parameters can't
 115  *          be met.
 116  */
 117 GLvisual *
 118 _mesa_create_visual( GLboolean rgbFlag,
 119                      GLboolean dbFlag,
 120                      GLboolean stereoFlag,
 121                      GLint redBits,
 122                      GLint greenBits,
 123                      GLint blueBits,
 124                      GLint alphaBits,
 125                      GLint indexBits,
 126                      GLint depthBits,
 127                      GLint stencilBits,
 128                      GLint accumRedBits,
 129                      GLint accumGreenBits,
 130                      GLint accumBlueBits,
 131                      GLint accumAlphaBits,
 132                      GLint numSamples )
 133 {
 134    GLvisual *vis = (GLvisual *) CALLOC( sizeof(GLvisual) );
 135    if (vis) {
 136       if (!_mesa_initialize_visual(vis, rgbFlag, dbFlag, stereoFlag,
 137                                    redBits, greenBits, blueBits, alphaBits,
 138                                    indexBits, depthBits, stencilBits,
 139                                    accumRedBits, accumGreenBits,
 140                                    accumBlueBits, accumAlphaBits,
 141                                    numSamples )) {
 142          FREE(vis);
 143          return NULL;
 144       }
 145    }
 146    return vis;
 147 }
 148
 149
 150 /*
 151  * Initialize the fields of the given GLvisual.
 152  * Input:  see _mesa_create_visual() above.
 153  * Return: GL_TRUE = success
 154  *         GL_FALSE = failure.
 155  */
 156 GLboolean
 157 _mesa_initialize_visual( GLvisual *vis,
 158                          GLboolean rgbFlag,
 159                          GLboolean dbFlag,
 160                          GLboolean stereoFlag,
 161                          GLint redBits,
 162                          GLint greenBits,
 163                          GLint blueBits,
 164                          GLint alphaBits,
 165                          GLint indexBits,
 166                          GLint depthBits,
 167                          GLint stencilBits,
 168                          GLint accumRedBits,
 169                          GLint accumGreenBits,
 170                          GLint accumBlueBits,
 171                          GLint accumAlphaBits,
 172                          GLint numSamples )
 173 {
 174    assert(vis);
 175
 176    /* This is to catch bad values from device drivers not updated for
 177     * Mesa 3.3.  Some device drivers just passed 1.  That's a REALLY
 178     * bad value now (a 1-bit depth buffer!?!).
 179     */
 180    assert(depthBits == 0 || depthBits > 1);
 181
 182    if (depthBits < 0 || depthBits > 32) {
 183       return GL_FALSE;
 184    }
 185    if (stencilBits < 0 || stencilBits > (GLint) (8 * sizeof(GLstencil))) {
 186       return GL_FALSE;
 187    }
 188    if (accumRedBits < 0 || accumRedBits > (GLint) (8 * sizeof(GLaccum))) {
 189       return GL_FALSE;
 190    }
 191    if (accumGreenBits < 0 || accumGreenBits > (GLint) (8 * sizeof(GLaccum))) {
 192       return GL_FALSE;
 193    }
 194    if (accumBlueBits < 0 || accumBlueBits > (GLint) (8 * sizeof(GLaccum))) {
 195       return GL_FALSE;
 196    }
 197    if (accumAlphaBits < 0 || accumAlphaBits > (GLint) (8 * sizeof(GLaccum))) {
 198       return GL_FALSE;
 199    }
 200
 201    vis->RGBAflag   = rgbFlag;
 202    vis->DBflag     = dbFlag;
 203    vis->StereoFlag = stereoFlag;
 204    vis->RedBits    = redBits;
 205    vis->GreenBits  = greenBits;
 206    vis->BlueBits   = blueBits;
 207    vis->AlphaBits  = alphaBits;
 208
 209    vis->IndexBits      = indexBits;
 210    vis->DepthBits      = depthBits;
 211    vis->AccumRedBits   = (accumRedBits > 0) ? (8 * sizeof(GLaccum)) : 0;
 212    vis->AccumGreenBits = (accumGreenBits > 0) ? (8 * sizeof(GLaccum)) : 0;
 213    vis->AccumBlueBits  = (accumBlueBits > 0) ? (8 * sizeof(GLaccum)) : 0;
 214    vis->AccumAlphaBits = (accumAlphaBits > 0) ? (8 * sizeof(GLaccum)) : 0;
 215    vis->StencilBits    = (stencilBits > 0) ? (8 * sizeof(GLstencil)) : 0;
 216
 217    if (depthBits == 0) {
 218       /* Special case.  Even if we don't have a depth buffer we need
 219        * good values for DepthMax for Z vertex transformation purposes.
 220        */
 221       vis->DepthMax = 1;
 222       vis->DepthMaxF = 1.0F;
 223    }
 224    else if (depthBits < 32) {
 225       vis->DepthMax = (1 << depthBits) - 1;
 226       vis->DepthMaxF = (GLfloat) vis->DepthMax;
 227    }
 228    else {
 229       /* Special case since shift values greater than or equal to the
 230        * number of bits in the left hand expression's type are
 231        * undefined.
 232        */
 233       vis->DepthMax = 0xffffffff;
 234       vis->DepthMaxF = (GLfloat) vis->DepthMax;
 235    }
 236
 237    return GL_TRUE;
 238 }
 239
 240
 241 /* This function should no longer be used. Use _mesa_create_visual() instead */
 242 GLvisual *
 243 gl_create_visual( GLboolean rgbFlag,
 244                   GLboolean alphaFlag,
 245                   GLboolean dbFlag,
 246                   GLboolean stereoFlag,
 247                   GLint depthBits,
 248                   GLint stencilBits,
 249                   GLint accumBits,
 250                   GLint indexBits,
 251                   GLint redBits,
 252                   GLint greenBits,
 253                   GLint blueBits,
 254                   GLint alphaBits )
 255 {
 256    (void) alphaFlag;
 257    return _mesa_create_visual(rgbFlag, dbFlag, stereoFlag,
 258                               redBits, greenBits, blueBits, alphaBits,
 259                               indexBits, depthBits, stencilBits,
 260                               accumBits, accumBits, accumBits, accumBits, 0);
 261 }
 262
 263
 264 void
 265 _mesa_destroy_visual( GLvisual *vis )
 266 {
 267    FREE(vis);
 268 }
 269
 270
 271 /* obsolete */
 272 void
 273 gl_destroy_visual( GLvisual *vis )
 274 {
 275    _mesa_destroy_visual(vis);
 276 }
 277
 278
 279
 280 /**********************************************************************/
 281 /***** GL Framebuffer allocation/destruction                      *****/
 282 /**********************************************************************/
 283
 284
 285 /*
 286  * Create a new framebuffer.  A GLframebuffer is a struct which
 287  * encapsulates the depth, stencil and accum buffers and related
 288  * parameters.
 289  * Input:  visual - a GLvisual pointer
 290  *         softwareDepth - create/use a software depth buffer?
 291  *         softwareStencil - create/use a software stencil buffer?
 292  *         softwareAccum - create/use a software accum buffer?
 293  *         softwareAlpha - create/use a software alpha buffer?
 294
 295  * Return:  pointer to new GLframebuffer struct or NULL if error.
 296  */
 297 GLframebuffer *
 298 gl_create_framebuffer( GLvisual *visual,
 299                        GLboolean softwareDepth,
 300                        GLboolean softwareStencil,
 301                        GLboolean softwareAccum,
 302                        GLboolean softwareAlpha )
 303 {
 304    GLframebuffer *buffer = CALLOC_STRUCT(gl_frame_buffer);
 305    assert(visual);
 306    if (buffer) {
 307       _mesa_initialize_framebuffer(buffer, visual,
 308                                    softwareDepth, softwareStencil,
 309                                    softwareAccum, softwareAlpha );
 310    }
 311    return buffer;
 312 }
 313
 314
 315 /*
 316  * Initialize a GLframebuffer object.
 317  * Input:  See gl_create_framebuffer() above.
 318  */
 319 void
 320 _mesa_initialize_framebuffer( GLframebuffer *buffer,
 321                               GLvisual *visual,
 322                               GLboolean softwareDepth,
 323                               GLboolean softwareStencil,
 324                               GLboolean softwareAccum,
 325                               GLboolean softwareAlpha )
 326 {
 327    assert(buffer);
 328    assert(visual);
 329
 330    /* sanity checks */
 331    if (softwareDepth ) {
 332       assert(visual->DepthBits > 0);
 333    }
 334    if (softwareStencil) {
 335       assert(visual->StencilBits > 0);
 336    }
 337    if (softwareAccum) {
 338       assert(visual->RGBAflag);
 339       assert(visual->AccumRedBits > 0);
 340       assert(visual->AccumGreenBits > 0);
 341       assert(visual->AccumBlueBits > 0);
 342    }
 343    if (softwareAlpha) {
 344       assert(visual->RGBAflag);
 345       assert(visual->AlphaBits > 0);
 346    }
 347
 348    buffer->Visual = visual;
 349    buffer->UseSoftwareDepthBuffer = softwareDepth;
 350    buffer->UseSoftwareStencilBuffer = softwareStencil;
 351    buffer->UseSoftwareAccumBuffer = softwareAccum;
 352    buffer->UseSoftwareAlphaBuffers = softwareAlpha;
 353 }
 354
 355
 356 /*
 357  * Free a framebuffer struct and its buffers.
 358  */
 359 void
 360 gl_destroy_framebuffer( GLframebuffer *buffer )
 361 {
 362    if (buffer) {
 363       if (buffer->DepthBuffer) {
 364          FREE( buffer->DepthBuffer );
 365       }
 366       if (buffer->Accum) {
 367          FREE( buffer->Accum );
 368       }
 369       if (buffer->Stencil) {
 370          FREE( buffer->Stencil );
 371       }
 372       if (buffer->FrontLeftAlpha) {
 373          FREE( buffer->FrontLeftAlpha );
 374       }
 375       if (buffer->BackLeftAlpha) {
 376          FREE( buffer->BackLeftAlpha );
 377       }
 378       if (buffer->FrontRightAlpha) {
 379          FREE( buffer->FrontRightAlpha );
 380       }
 381       if (buffer->BackRightAlpha) {
 382          FREE( buffer->BackRightAlpha );
 383       }
 384       FREE(buffer);
 385    }
 386 }
 387
 388
 389
 390 /**********************************************************************/
 391 /*****       Context allocation, initialization, destroying       *****/
 392 /**********************************************************************/
 393
 394
 395 _glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
 396
 397
 398 /*
 399  * This function just calls all the various one-time-init functions in Mesa.
 400  */
 401 static void
 402 one_time_init( void )
 403 {
 404    static GLboolean alreadyCalled = GL_FALSE;
 405    _glthread_LOCK_MUTEX(OneTimeLock);
 406    if (!alreadyCalled) {
 407       /* do some implementation tests */
 408       assert( sizeof(GLbyte) == 1 );
 409       assert( sizeof(GLshort) >= 2 );
 410       assert( sizeof(GLint) >= 4 );
 411       assert( sizeof(GLubyte) == 1 );
 412       assert( sizeof(GLushort) >= 2 );
 413       assert( sizeof(GLuint) >= 4 );
 414
 415       gl_init_clip();
 416       gl_init_eval();
 417       _mesa_init_fog();
 418       _mesa_init_math();
 419       gl_init_lists();
 420       gl_init_shade();
 421       gl_init_texture();
 422       gl_init_transformation();
 423       gl_init_translate();
 424       gl_init_vbrender();
 425       gl_init_vbxform();
 426       gl_init_vertices();
 427
 428       if (getenv("MESA_DEBUG")) {
 429          _glapi_noop_enable_warnings(GL_TRUE);
 430       }
 431       else {
 432          _glapi_noop_enable_warnings(GL_FALSE);
 433       }
 434
 435 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
 436    fprintf(stderr, "Mesa DEBUG build %s %s\n", __DATE__, __TIME__);
 437 #endif
 438
 439       alreadyCalled = GL_TRUE;
 440    }
 441    _glthread_UNLOCK_MUTEX(OneTimeLock);
 442 }
 443
 444
 445
 446 /*
 447  * Allocate and initialize a shared context state structure.
 448  */
 449 static struct gl_shared_state *
 450 alloc_shared_state( void )
 451 {
 452    GLuint d;
 453    struct gl_shared_state *ss;
 454    GLboolean outOfMemory;
 455
 456    ss = CALLOC_STRUCT(gl_shared_state);
 457    if (!ss)
 458       return NULL;
 459
 460    _glthread_INIT_MUTEX(ss->Mutex);
 461
 462    ss->DisplayList = _mesa_NewHashTable();
 463    ss->TexObjects = _mesa_NewHashTable();
 464
 465    /* Default Texture objects */
 466    outOfMemory = GL_FALSE;
 467    for (d = 1 ; d <= 3 ; d++) {
 468       ss->DefaultD[d] = gl_alloc_texture_object(ss, 0, d);
 469       if (!ss->DefaultD[d]) {
 470          outOfMemory = GL_TRUE;
 471          break;
 472       }
 473       ss->DefaultD[d]->RefCount++; /* don't free if not in use */
 474    }
 475
 476    ss->DefaultCubeMap = gl_alloc_texture_object(ss, 0, 6);
 477    if (!ss->DefaultCubeMap) {
 478       outOfMemory = GL_TRUE;
 479    }
 480    else {
 481       ss->DefaultCubeMap->RefCount++;
 482    }
 483
 484    if (!ss->DisplayList || !ss->TexObjects || outOfMemory) {
 485       /* Ran out of memory at some point.  Free everything and return NULL */
 486       if (ss->DisplayList)
 487          _mesa_DeleteHashTable(ss->DisplayList);
 488       if (ss->TexObjects)
 489          _mesa_DeleteHashTable(ss->TexObjects);
 490       if (ss->DefaultD[1])
 491          gl_free_texture_object(ss, ss->DefaultD[1]);
 492       if (ss->DefaultD[2])
 493          gl_free_texture_object(ss, ss->DefaultD[2]);
 494       if (ss->DefaultD[3])
 495          gl_free_texture_object(ss, ss->DefaultD[3]);
 496       if (ss->DefaultCubeMap)
 497          gl_free_texture_object(ss, ss->DefaultCubeMap);
 498       FREE(ss);
 499       return NULL;
 500    }
 501    else {
 502       return ss;
 503    }
 504 }
 505
 506
 507 /*
 508  * Deallocate a shared state context and all children structures.
 509  */
 510 static void
 511 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
 512 {
 513    /* Free display lists */
 514    while (1) {
 515       GLuint list = _mesa_HashFirstEntry(ss->DisplayList);
 516       if (list) {
 517          gl_destroy_list(ctx, list);
 518       }
 519       else {
 520          break;
 521       }
 522    }
 523    _mesa_DeleteHashTable(ss->DisplayList);
 524
 525    /* Free texture objects */
 526    while (ss->TexObjectList)
 527    {
 528       if (ctx->Driver.DeleteTexture)
 529          (*ctx->Driver.DeleteTexture)( ctx, ss->TexObjectList );
 530       /* this function removes from linked list too! */
 531       gl_free_texture_object(ss, ss->TexObjectList);
 532    }
 533    _mesa_DeleteHashTable(ss->TexObjects);
 534
 535    FREE(ss);
 536 }
 537
 538
 539
 540 /*
 541  * Initialize the nth light.  Note that the defaults for light 0 are
 542  * different than the other lights.
 543  */
 544 static void
 545 init_light( struct gl_light *l, GLuint n )
 546 {
 547    make_empty_list( l );
 548
 549    ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 );
 550    if (n==0) {
 551       ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 );
 552       ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 );
 553    }
 554    else {
 555       ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 );
 556       ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 );
 557    }
 558    ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 );
 559    ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 );
 560    l->SpotExponent = 0.0;
 561    gl_compute_spot_exp_table( l );
 562    l->SpotCutoff = 180.0;
 563    l->CosCutoff = 0.0;          /* KW: -ve values not admitted */
 564    l->ConstantAttenuation = 1.0;
 565    l->LinearAttenuation = 0.0;
 566    l->QuadraticAttenuation = 0.0;
 567    l->Enabled = GL_FALSE;
 568 }
 569
 570
 571
 572 static void
 573 init_lightmodel( struct gl_lightmodel *lm )
 574 {
 575    ASSIGN_4V( lm->Ambient, 0.2, 0.2, 0.2, 1.0 );
 576    lm->LocalViewer = GL_FALSE;
 577    lm->TwoSide = GL_FALSE;
 578    lm->ColorControl = GL_SINGLE_COLOR;
 579 }
 580
 581
 582 static void
 583 init_material( struct gl_material *m )
 584 {
 585    ASSIGN_4V( m->Ambient,  0.2, 0.2, 0.2, 1.0 );
 586    ASSIGN_4V( m->Diffuse,  0.8, 0.8, 0.8, 1.0 );
 587    ASSIGN_4V( m->Specular, 0.0, 0.0, 0.0, 1.0 );
 588    ASSIGN_4V( m->Emission, 0.0, 0.0, 0.0, 1.0 );
 589    m->Shininess = 0.0;
 590    m->AmbientIndex = 0;
 591    m->DiffuseIndex = 1;
 592    m->SpecularIndex = 1;
 593 }
 594
 595
 596
 597 static void
 598 init_texture_unit( GLcontext *ctx, GLuint unit )
 599 {
 600    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 601
 602    texUnit->EnvMode = GL_MODULATE;
 603    texUnit->CombineModeRGB = GL_MODULATE;
 604    texUnit->CombineModeA = GL_MODULATE;
 605    texUnit->CombineSourceRGB[0] = GL_TEXTURE;
 606    texUnit->CombineSourceRGB[1] = GL_PREVIOUS_EXT;
 607    texUnit->CombineSourceRGB[2] = GL_CONSTANT_EXT;
 608    texUnit->CombineSourceA[0] = GL_TEXTURE;
 609    texUnit->CombineSourceA[1] = GL_PREVIOUS_EXT;
 610    texUnit->CombineSourceA[2] = GL_CONSTANT_EXT;
 611    texUnit->CombineOperandRGB[0] = GL_SRC_COLOR;
 612    texUnit->CombineOperandRGB[1] = GL_SRC_COLOR;
 613    texUnit->CombineOperandRGB[2] = GL_SRC_ALPHA;
 614    texUnit->CombineOperandA[0] = GL_SRC_ALPHA;
 615    texUnit->CombineOperandA[1] = GL_SRC_ALPHA;
 616    texUnit->CombineOperandA[2] = GL_SRC_ALPHA;
 617    texUnit->CombineScaleShiftRGB = 0;
 618    texUnit->CombineScaleShiftA = 0;
 619
 620    ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
 621    texUnit->TexGenEnabled = 0;
 622    texUnit->GenModeS = GL_EYE_LINEAR;
 623    texUnit->GenModeT = GL_EYE_LINEAR;
 624    texUnit->GenModeR = GL_EYE_LINEAR;
 625    texUnit->GenModeQ = GL_EYE_LINEAR;
 626    texUnit->GenBitS = TEXGEN_EYE_LINEAR;
 627    texUnit->GenBitT = TEXGEN_EYE_LINEAR;
 628    texUnit->GenBitR = TEXGEN_EYE_LINEAR;
 629    texUnit->GenBitQ = TEXGEN_EYE_LINEAR;
 630
 631    /* Yes, these plane coefficients are correct! */
 632    ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 );
 633    ASSIGN_4V( texUnit->ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 );
 634    ASSIGN_4V( texUnit->ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 );
 635    ASSIGN_4V( texUnit->ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 );
 636    ASSIGN_4V( texUnit->EyePlaneS, 1.0, 0.0, 0.0, 0.0 );
 637    ASSIGN_4V( texUnit->EyePlaneT, 0.0, 1.0, 0.0, 0.0 );
 638    ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 );
 639    ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 );
 640
 641    texUnit->CurrentD[1] = ctx->Shared->DefaultD[1];
 642    texUnit->CurrentD[2] = ctx->Shared->DefaultD[2];
 643    texUnit->CurrentD[3] = ctx->Shared->DefaultD[3];
 644    texUnit->CurrentCubeMap = ctx->Shared->DefaultCubeMap;
 645 }
 646
 647
 648 static void
 649 init_fallback_arrays( GLcontext *ctx )
 650 {
 651    struct gl_client_array *cl;
 652    GLuint i;
 653
 654    cl = &ctx->Fallback.Normal;
 655    cl->Size = 3;
 656    cl->Type = GL_FLOAT;
 657    cl->Stride = 0;
 658    cl->StrideB = 0;
 659    cl->Ptr = (void *) ctx->Current.Normal;
 660    cl->Enabled = 1;
 661
 662    cl = &ctx->Fallback.Color;
 663    cl->Size = 4;
 664    cl->Type = GL_UNSIGNED_BYTE;
 665    cl->Stride = 0;
 666    cl->StrideB = 0;
 667    cl->Ptr = (void *) ctx->Current.ByteColor;
 668    cl->Enabled = 1;
 669
 670    cl = &ctx->Fallback.Index;
 671    cl->Size = 1;
 672    cl->Type = GL_UNSIGNED_INT;
 673    cl->Stride = 0;
 674    cl->StrideB = 0;
 675    cl->Ptr = (void *) &ctx->Current.Index;
 676    cl->Enabled = 1;
 677
 678    for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) {
 679       cl = &ctx->Fallback.TexCoord[i];
 680       cl->Size = 4;
 681       cl->Type = GL_FLOAT;
 682       cl->Stride = 0;
 683       cl->StrideB = 0;
 684       cl->Ptr = (void *) ctx->Current.Texcoord[i];
 685       cl->Enabled = 1;
 686    }
 687
 688    cl = &ctx->Fallback.EdgeFlag;
 689    cl->Size = 1;
 690    cl->Type = GL_UNSIGNED_BYTE;
 691    cl->Stride = 0;
 692    cl->StrideB = 0;
 693    cl->Ptr = (void *) &ctx->Current.EdgeFlag;
 694    cl->Enabled = 1;
 695 }
 696
 697
 698 /* Initialize a 1-D evaluator map */
 699 static void
 700 init_1d_map( struct gl_1d_map *map, int n, const float *initial )
 701 {
 702    map->Order = 1;
 703    map->u1 = 0.0;
 704    map->u2 = 1.0;
 705    map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat));
 706    if (map->Points) {
 707       GLint i;
 708       for (i=0;i<n;i++)
 709          map->Points[i] = initial[i];
 710    }
 711 }
 712
 713
 714 /* Initialize a 2-D evaluator map */
 715 static void
 716 init_2d_map( struct gl_2d_map *map, int n, const float *initial )
 717 {
 718    map->Uorder = 1;
 719    map->Vorder = 1;
 720    map->u1 = 0.0;
 721    map->u2 = 1.0;
 722    map->v1 = 0.0;
 723    map->v2 = 1.0;
 724    map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat));
 725    if (map->Points) {
 726       GLint i;
 727       for (i=0;i<n;i++)
 728          map->Points[i] = initial[i];
 729    }
 730 }
 731
 732
 733 /*
 734  * Initialize the attribute groups in a GLcontext.
 735  */
 736 static void
 737 init_attrib_groups( GLcontext *ctx )
 738 {
 739    GLuint i, j;
 740
 741    assert(ctx);
 742
 743    /* Constants, may be overriden by device drivers */
 744    ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
 745    ctx->Const.MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
 746    ctx->Const.MaxCubeTextureSize = ctx->Const.MaxTextureSize;
 747    ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
 748    ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
 749    ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
 750    ctx->Const.MinPointSize = MIN_POINT_SIZE;
 751    ctx->Const.MaxPointSize = MAX_POINT_SIZE;
 752    ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
 753    ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
 754    ctx->Const.PointSizeGranularity = POINT_SIZE_GRANULARITY;
 755    ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
 756    ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
 757    ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
 758    ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
 759    ctx->Const.LineWidthGranularity = LINE_WIDTH_GRANULARITY;
 760    ctx->Const.NumAuxBuffers = NUM_AUX_BUFFERS;
 761    ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
 762    ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
 763    ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
 764    ctx->Const.NumCompressedTextureFormats = 0;
 765
 766    /* Modelview matrix */
 767    gl_matrix_ctr( &ctx->ModelView );
 768    gl_matrix_alloc_inv( &ctx->ModelView );
 769
 770    ctx->ModelViewStackDepth = 0;
 771    for (i = 0; i < MAX_MODELVIEW_STACK_DEPTH - 1; i++) {
 772       gl_matrix_ctr( &ctx->ModelViewStack[i] );
 773       gl_matrix_alloc_inv( &ctx->ModelViewStack[i] );
 774    }
 775
 776    /* Projection matrix - need inv for user clipping in clip space*/
 777    gl_matrix_ctr( &ctx->ProjectionMatrix );
 778    gl_matrix_alloc_inv( &ctx->ProjectionMatrix );
 779
 780    gl_matrix_ctr( &ctx->ModelProjectMatrix );
 781    gl_matrix_ctr( &ctx->ModelProjectWinMatrix );
 782    ctx->ModelProjectWinMatrixUptodate = GL_FALSE;
 783
 784    ctx->ProjectionStackDepth = 0;
 785    ctx->NearFarStack[0][0] = 1.0; /* These values seem weird by make */
 786    ctx->NearFarStack[0][1] = 0.0; /* sense mathematically. */
 787
 788    for (i = 0; i < MAX_PROJECTION_STACK_DEPTH - 1; i++) {
 789       gl_matrix_ctr( &ctx->ProjectionStack[i] );
 790       gl_matrix_alloc_inv( &ctx->ProjectionStack[i] );
 791    }
 792
 793    /* Texture matrix */
 794    for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
 795       gl_matrix_ctr( &ctx->TextureMatrix[i] );
 796       ctx->TextureStackDepth[i] = 0;
 797       for (j = 0; j < MAX_TEXTURE_STACK_DEPTH - 1; j++) {
 798          gl_matrix_ctr( &ctx->TextureStack[i][j] );
 799          ctx->TextureStack[i][j].inv = 0;
 800       }
 801    }
 802
 803    /* Color matrix */
 804    gl_matrix_ctr(&ctx->ColorMatrix);
 805    ctx->ColorStackDepth = 0;
 806    for (j = 0; j < MAX_COLOR_STACK_DEPTH - 1; j++) {
 807       gl_matrix_ctr(&ctx->ColorStack[j]);
 808    }
 809
 810    /* Accumulate buffer group */
 811    ASSIGN_4V( ctx->Accum.ClearColor, 0.0, 0.0, 0.0, 0.0 );
 812
 813    /* Color buffer group */
 814    ctx->Color.IndexMask = 0xffffffff;
 815    ctx->Color.ColorMask[0] = 0xff;
 816    ctx->Color.ColorMask[1] = 0xff;
 817    ctx->Color.ColorMask[2] = 0xff;
 818    ctx->Color.ColorMask[3] = 0xff;
 819    ctx->Color.ClearIndex = 0;
 820    ASSIGN_4V( ctx->Color.ClearColor, 0.0, 0.0, 0.0, 0.0 );
 821    ctx->Color.DrawBuffer = GL_FRONT;
 822    ctx->Color.AlphaEnabled = GL_FALSE;
 823    ctx->Color.AlphaFunc = GL_ALWAYS;
 824    ctx->Color.AlphaRef = 0;
 825    ctx->Color.BlendEnabled = GL_FALSE;
 826    ctx->Color.BlendSrcRGB = GL_ONE;
 827    ctx->Color.BlendDstRGB = GL_ZERO;
 828    ctx->Color.BlendSrcA = GL_ONE;
 829    ctx->Color.BlendDstA = GL_ZERO;
 830    ctx->Color.BlendEquation = GL_FUNC_ADD_EXT;
 831    ctx->Color.BlendFunc = NULL;  /* this pointer set only when needed */
 832    ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );
 833    ctx->Color.IndexLogicOpEnabled = GL_FALSE;
 834    ctx->Color.ColorLogicOpEnabled = GL_FALSE;
 835    ctx->Color.LogicOp = GL_COPY;
 836    ctx->Color.DitherFlag = GL_TRUE;
 837    ctx->Color.MultiDrawBuffer = GL_FALSE;
 838
 839    /* Current group */
 840    ASSIGN_4V( ctx->Current.ByteColor, 255, 255, 255, 255);
 841    ctx->Current.Index = 1;
 842    for (i=0; i<MAX_TEXTURE_UNITS; i++)
 843       ASSIGN_4V( ctx->Current.Texcoord[i], 0.0, 0.0, 0.0, 1.0 );
 844    ASSIGN_4V( ctx->Current.RasterPos, 0.0, 0.0, 0.0, 1.0 );
 845    ctx->Current.RasterDistance = 0.0;
 846    ASSIGN_4V( ctx->Current.RasterColor, 1.0, 1.0, 1.0, 1.0 );
 847    ctx->Current.RasterIndex = 1;
 848    for (i=0; i<MAX_TEXTURE_UNITS; i++)
 849       ASSIGN_4V( ctx->Current.RasterMultiTexCoord[i], 0.0, 0.0, 0.0, 1.0 );
 850    ctx->Current.RasterTexCoord = ctx->Current.RasterMultiTexCoord[0];
 851    ctx->Current.RasterPosValid = GL_TRUE;
 852    ctx->Current.EdgeFlag = GL_TRUE;
 853    ASSIGN_3V( ctx->Current.Normal, 0.0, 0.0, 1.0 );
 854    ctx->Current.Primitive = (GLenum) (GL_POLYGON + 1);
 855
 856    ctx->Current.Flag = (VERT_NORM|VERT_INDEX|VERT_RGBA|VERT_EDGE|
 857                         VERT_TEX0_1|VERT_TEX1_1|VERT_MATERIAL);
 858
 859    init_fallback_arrays( ctx );
 860
 861    /* Depth buffer group */
 862    ctx->Depth.Test = GL_FALSE;
 863    ctx->Depth.Clear = 1.0;
 864    ctx->Depth.Func = GL_LESS;
 865    ctx->Depth.Mask = GL_TRUE;
 866    ctx->Depth.OcclusionTest = GL_FALSE;
 867
 868    /* Evaluators group */
 869    ctx->Eval.Map1Color4 = GL_FALSE;
 870    ctx->Eval.Map1Index = GL_FALSE;
 871    ctx->Eval.Map1Normal = GL_FALSE;
 872    ctx->Eval.Map1TextureCoord1 = GL_FALSE;
 873    ctx->Eval.Map1TextureCoord2 = GL_FALSE;
 874    ctx->Eval.Map1TextureCoord3 = GL_FALSE;
 875    ctx->Eval.Map1TextureCoord4 = GL_FALSE;
 876    ctx->Eval.Map1Vertex3 = GL_FALSE;
 877    ctx->Eval.Map1Vertex4 = GL_FALSE;
 878    ctx->Eval.Map2Color4 = GL_FALSE;
 879    ctx->Eval.Map2Index = GL_FALSE;
 880    ctx->Eval.Map2Normal = GL_FALSE;
 881    ctx->Eval.Map2TextureCoord1 = GL_FALSE;
 882    ctx->Eval.Map2TextureCoord2 = GL_FALSE;
 883    ctx->Eval.Map2TextureCoord3 = GL_FALSE;
 884    ctx->Eval.Map2TextureCoord4 = GL_FALSE;
 885    ctx->Eval.Map2Vertex3 = GL_FALSE;
 886    ctx->Eval.Map2Vertex4 = GL_FALSE;
 887    ctx->Eval.AutoNormal = GL_FALSE;
 888    ctx->Eval.MapGrid1un = 1;
 889    ctx->Eval.MapGrid1u1 = 0.0;
 890    ctx->Eval.MapGrid1u2 = 1.0;
 891    ctx->Eval.MapGrid2un = 1;
 892    ctx->Eval.MapGrid2vn = 1;
 893    ctx->Eval.MapGrid2u1 = 0.0;
 894    ctx->Eval.MapGrid2u2 = 1.0;
 895    ctx->Eval.MapGrid2v1 = 0.0;
 896    ctx->Eval.MapGrid2v2 = 1.0;
 897
 898    /* Evaluator data */
 899    {
 900       static GLfloat vertex[4] = { 0.0, 0.0, 0.0, 1.0 };
 901       static GLfloat normal[3] = { 0.0, 0.0, 1.0 };
 902       static GLfloat index[1] = { 1.0 };
 903       static GLfloat color[4] = { 1.0, 1.0, 1.0, 1.0 };
 904       static GLfloat texcoord[4] = { 0.0, 0.0, 0.0, 1.0 };
 905
 906       init_1d_map( &ctx->EvalMap.Map1Vertex3, 3, vertex );
 907       init_1d_map( &ctx->EvalMap.Map1Vertex4, 4, vertex );
 908       init_1d_map( &ctx->EvalMap.Map1Index, 1, index );
 909       init_1d_map( &ctx->EvalMap.Map1Color4, 4, color );
 910       init_1d_map( &ctx->EvalMap.Map1Normal, 3, normal );
 911       init_1d_map( &ctx->EvalMap.Map1Texture1, 1, texcoord );
 912       init_1d_map( &ctx->EvalMap.Map1Texture2, 2, texcoord );
 913       init_1d_map( &ctx->EvalMap.Map1Texture3, 3, texcoord );
 914       init_1d_map( &ctx->EvalMap.Map1Texture4, 4, texcoord );
 915
 916       init_2d_map( &ctx->EvalMap.Map2Vertex3, 3, vertex );
 917       init_2d_map( &ctx->EvalMap.Map2Vertex4, 4, vertex );
 918       init_2d_map( &ctx->EvalMap.Map2Index, 1, index );
 919       init_2d_map( &ctx->EvalMap.Map2Color4, 4, color );
 920       init_2d_map( &ctx->EvalMap.Map2Normal, 3, normal );
 921       init_2d_map( &ctx->EvalMap.Map2Texture1, 1, texcoord );
 922       init_2d_map( &ctx->EvalMap.Map2Texture2, 2, texcoord );
 923       init_2d_map( &ctx->EvalMap.Map2Texture3, 3, texcoord );
 924       init_2d_map( &ctx->EvalMap.Map2Texture4, 4, texcoord );
 925    }
 926
 927    /* Fog group */
 928    ctx->Fog.Enabled = GL_FALSE;
 929    ctx->Fog.Mode = GL_EXP;
 930    ASSIGN_4V( ctx->Fog.Color, 0.0, 0.0, 0.0, 0.0 );
 931    ctx->Fog.Index = 0.0;
 932    ctx->Fog.Density = 1.0;
 933    ctx->Fog.Start = 0.0;
 934    ctx->Fog.End = 1.0;
 935
 936    /* Hint group */
 937    ctx->Hint.PerspectiveCorrection = GL_DONT_CARE;
 938    ctx->Hint.PointSmooth = GL_DONT_CARE;
 939    ctx->Hint.LineSmooth = GL_DONT_CARE;
 940    ctx->Hint.PolygonSmooth = GL_DONT_CARE;
 941    ctx->Hint.Fog = GL_DONT_CARE;
 942    ctx->Hint.AllowDrawWin = GL_TRUE;
 943    ctx->Hint.AllowDrawFrg = GL_TRUE;
 944    ctx->Hint.AllowDrawMem = GL_TRUE;
 945    ctx->Hint.StrictLighting = GL_TRUE;
 946    ctx->Hint.ClipVolumeClipping = GL_DONT_CARE;
 947    ctx->Hint.TextureCompression = GL_DONT_CARE;
 948
 949    /* Histogram group */
 950    ctx->Histogram.Width = 0;
 951    ctx->Histogram.Format = GL_RGBA;
 952    ctx->Histogram.Sink = GL_FALSE;
 953    ctx->Histogram.RedSize       = 0xffffffff;
 954    ctx->Histogram.GreenSize     = 0xffffffff;
 955    ctx->Histogram.BlueSize      = 0xffffffff;
 956    ctx->Histogram.AlphaSize     = 0xffffffff;
 957    ctx->Histogram.LuminanceSize = 0xffffffff;
 958    for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
 959       ctx->Histogram.Count[i][0] = 0;
 960       ctx->Histogram.Count[i][1] = 0;
 961       ctx->Histogram.Count[i][2] = 0;
 962       ctx->Histogram.Count[i][3] = 0;
 963    }
 964
 965    /* Min/Max group */
 966    ctx->MinMax.Format = GL_RGBA;
 967    ctx->MinMax.Sink = GL_FALSE;
 968    ctx->MinMax.Min[RCOMP] = 1000;    ctx->MinMax.Max[RCOMP] = -1000;
 969    ctx->MinMax.Min[GCOMP] = 1000;    ctx->MinMax.Max[GCOMP] = -1000;
 970    ctx->MinMax.Min[BCOMP] = 1000;    ctx->MinMax.Max[BCOMP] = -1000;
 971    ctx->MinMax.Min[ACOMP] = 1000;    ctx->MinMax.Max[ACOMP] = -1000;
 972
 973
 974
 975    /* Pipeline */
 976    gl_pipeline_init( ctx );
 977    gl_cva_init( ctx );
 978
 979    /* Extensions */
 980    gl_extensions_ctr( ctx );
 981
 982    ctx->AllowVertexCull = CLIP_CULLED_BIT;
 983
 984    /* Lighting group */
 985    for (i=0;i<MAX_LIGHTS;i++) {
 986       init_light( &ctx->Light.Light[i], i );
 987    }
 988    make_empty_list( &ctx->Light.EnabledList );
 989
 990    init_lightmodel( &ctx->Light.Model );
 991    init_material( &ctx->Light.Material[0] );
 992    init_material( &ctx->Light.Material[1] );
 993    ctx->Light.ShadeModel = GL_SMOOTH;
 994    ctx->Light.Enabled = GL_FALSE;
 995    ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK;
 996    ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE;
 997    ctx->Light.ColorMaterialBitmask
 998       = gl_material_bitmask( ctx,
 999                              GL_FRONT_AND_BACK,
1000                              GL_AMBIENT_AND_DIFFUSE, ~0, 0 );
1001
1002    ctx->Light.ColorMaterialEnabled = GL_FALSE;
1003
1004    /* Lighting miscellaneous */
1005    ctx->ShineTabList = MALLOC_STRUCT( gl_shine_tab );
1006    make_empty_list( ctx->ShineTabList );
1007    for (i = 0 ; i < 10 ; i++) {
1008       struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab );
1009       s->shininess = -1;
1010       s->refcount = 0;
1011       insert_at_tail( ctx->ShineTabList, s );
1012    }
1013    for (i = 0 ; i < 4 ; i++) {
1014       ctx->ShineTable[i] = ctx->ShineTabList->prev;
1015       ctx->ShineTable[i]->refcount++;
1016    }
1017
1018    gl_compute_shine_table( ctx, 0, ctx->Light.Material[0].Shininess );
1019    gl_compute_shine_table( ctx, 2, ctx->Light.Material[0].Shininess * .5 );
1020    gl_compute_shine_table( ctx, 1, ctx->Light.Material[1].Shininess );
1021    gl_compute_shine_table( ctx, 3, ctx->Light.Material[1].Shininess * .5 );
1022
1023
1024    /* Line group */
1025    ctx->Line.SmoothFlag = GL_FALSE;
1026    ctx->Line.StippleFlag = GL_FALSE;
1027    ctx->Line.Width = 1.0;
1028    ctx->Line.StipplePattern = 0xffff;
1029    ctx->Line.StippleFactor = 1;
1030
1031    /* Display List group */
1032    ctx->List.ListBase = 0;
1033
1034    /* Pixel group */
1035    ctx->Pixel.RedBias = 0.0;
1036    ctx->Pixel.RedScale = 1.0;
1037    ctx->Pixel.GreenBias = 0.0;
1038    ctx->Pixel.GreenScale = 1.0;
1039    ctx->Pixel.BlueBias = 0.0;
1040    ctx->Pixel.BlueScale = 1.0;
1041    ctx->Pixel.AlphaBias = 0.0;
1042    ctx->Pixel.AlphaScale = 1.0;
1043    ctx->Pixel.DepthBias = 0.0;
1044    ctx->Pixel.DepthScale = 1.0;
1045    ctx->Pixel.IndexOffset = 0;
1046    ctx->Pixel.IndexShift = 0;
1047    ctx->Pixel.ZoomX = 1.0;
1048    ctx->Pixel.ZoomY = 1.0;
1049    ctx->Pixel.MapColorFlag = GL_FALSE;
1050    ctx->Pixel.MapStencilFlag = GL_FALSE;
1051    ctx->Pixel.MapStoSsize = 1;
1052    ctx->Pixel.MapItoIsize = 1;
1053    ctx->Pixel.MapItoRsize = 1;
1054    ctx->Pixel.MapItoGsize = 1;
1055    ctx->Pixel.MapItoBsize = 1;
1056    ctx->Pixel.MapItoAsize = 1;
1057    ctx->Pixel.MapRtoRsize = 1;
1058    ctx->Pixel.MapGtoGsize = 1;
1059    ctx->Pixel.MapBtoBsize = 1;
1060    ctx->Pixel.MapAtoAsize = 1;
1061    ctx->Pixel.MapStoS[0] = 0;
1062    ctx->Pixel.MapItoI[0] = 0;
1063    ctx->Pixel.MapItoR[0] = 0.0;
1064    ctx->Pixel.MapItoG[0] = 0.0;
1065    ctx->Pixel.MapItoB[0] = 0.0;
1066    ctx->Pixel.MapItoA[0] = 0.0;
1067    ctx->Pixel.MapItoR8[0] = 0;
1068    ctx->Pixel.MapItoG8[0] = 0;
1069    ctx->Pixel.MapItoB8[0] = 0;
1070    ctx->Pixel.MapItoA8[0] = 0;
1071    ctx->Pixel.MapRtoR[0] = 0.0;
1072    ctx->Pixel.MapGtoG[0] = 0.0;
1073    ctx->Pixel.MapBtoB[0] = 0.0;
1074    ctx->Pixel.MapAtoA[0] = 0.0;
1075    ctx->Pixel.HistogramEnabled = GL_FALSE;
1076    ctx->Pixel.MinMaxEnabled = GL_FALSE;
1077    ctx->Pixel.PixelTextureEnabled = GL_FALSE;
1078    ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
1079    ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
1080    ASSIGN_4V(ctx->Pixel.PostColorMatrixScale, 1.0, 1.0, 1.0, 1.0);
1081    ASSIGN_4V(ctx->Pixel.PostColorMatrixBias, 0.0, 0.0, 0.0, 0.0);
1082    ASSIGN_4V(ctx->Pixel.ColorTableScale, 1.0, 1.0, 1.0, 1.0);
1083    ASSIGN_4V(ctx->Pixel.ColorTableBias, 0.0, 0.0, 0.0, 0.0);
1084    ASSIGN_4V(ctx->Pixel.PCCTscale, 1.0, 1.0, 1.0, 1.0);
1085    ASSIGN_4V(ctx->Pixel.PCCTbias, 0.0, 0.0, 0.0, 0.0);
1086    ASSIGN_4V(ctx->Pixel.PCMCTscale, 1.0, 1.0, 1.0, 1.0);
1087    ASSIGN_4V(ctx->Pixel.PCMCTbias, 0.0, 0.0, 0.0, 0.0);
1088    ctx->Pixel.ColorTableEnabled = GL_FALSE;
1089    ctx->Pixel.PostConvolutionColorTableEnabled = GL_FALSE;
1090    ctx->Pixel.PostColorMatrixColorTableEnabled = GL_FALSE;
1091    ctx->Pixel.Convolution1DEnabled = GL_FALSE;
1092    ctx->Pixel.Convolution2DEnabled = GL_FALSE;
1093    ctx->Pixel.Separable2DEnabled = GL_FALSE;
1094    for (i = 0; i < 3; i++) {
1095       ASSIGN_4V(ctx->Pixel.ConvolutionBorderColor[i], 0.0, 0.0, 0.0, 0.0);
1096       ctx->Pixel.ConvolutionBorderMode[i] = GL_REDUCE;
1097       ASSIGN_4V(ctx->Pixel.ConvolutionFilterScale[i], 1.0, 1.0, 1.0, 1.0);
1098       ASSIGN_4V(ctx->Pixel.ConvolutionFilterBias[i], 0.0, 0.0, 0.0, 0.0);
1099    }
1100    ASSIGN_4V(ctx->Pixel.PostConvolutionScale, 1.0, 1.0, 1.0, 1.0);
1101    ASSIGN_4V(ctx->Pixel.PostConvolutionBias, 0.0, 0.0, 0.0, 0.0);
1102
1103    /* Point group */
1104    ctx->Point.SmoothFlag = GL_FALSE;
1105    ctx->Point.UserSize = 1.0;
1106    ctx->Point.Size = 1.0;
1107    ctx->Point.Params[0] = 1.0;
1108    ctx->Point.Params[1] = 0.0;
1109    ctx->Point.Params[2] = 0.0;
1110    ctx->Point.Attenuated = GL_FALSE;
1111    ctx->Point.MinSize = 0.0;
1112    ctx->Point.MaxSize = (GLfloat) MAX_POINT_SIZE;
1113    ctx->Point.Threshold = 1.0;
1114
1115    /* Polygon group */
1116    ctx->Polygon.CullFlag = GL_FALSE;
1117    ctx->Polygon.CullFaceMode = GL_BACK;
1118    ctx->Polygon.FrontFace = GL_CCW;
1119    ctx->Polygon.FrontBit = 0;
1120    ctx->Polygon.FrontMode = GL_FILL;
1121    ctx->Polygon.BackMode = GL_FILL;
1122    ctx->Polygon.Unfilled = GL_FALSE;
1123    ctx->Polygon.SmoothFlag = GL_FALSE;
1124    ctx->Polygon.StippleFlag = GL_FALSE;
1125    ctx->Polygon.OffsetFactor = 0.0F;
1126    ctx->Polygon.OffsetUnits = 0.0F;
1127    ctx->Polygon.OffsetPoint = GL_FALSE;
1128    ctx->Polygon.OffsetLine = GL_FALSE;
1129    ctx->Polygon.OffsetFill = GL_FALSE;
1130
1131    /* Polygon Stipple group */
1132    MEMSET( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) );
1133
1134    /* Scissor group */
1135    ctx->Scissor.Enabled = GL_FALSE;
1136    ctx->Scissor.X = 0;
1137    ctx->Scissor.Y = 0;
1138    ctx->Scissor.Width = 0;
1139    ctx->Scissor.Height = 0;
1140
1141    /* Stencil group */
1142    ctx->Stencil.Enabled = GL_FALSE;
1143    ctx->Stencil.Function = GL_ALWAYS;
1144    ctx->Stencil.FailFunc = GL_KEEP;
1145    ctx->Stencil.ZPassFunc = GL_KEEP;
1146    ctx->Stencil.ZFailFunc = GL_KEEP;
1147    ctx->Stencil.Ref = 0;
1148    ctx->Stencil.ValueMask = STENCIL_MAX;
1149    ctx->Stencil.Clear = 0;
1150    ctx->Stencil.WriteMask = STENCIL_MAX;
1151
1152    /* Texture group */
1153    ctx->Texture.CurrentUnit = 0;      /* multitexture */
1154    ctx->Texture.CurrentTransformUnit = 0; /* multitexture */
1155    ctx->Texture.Enabled = 0;
1156    ctx->Texture.ReallyEnabled = 0;
1157    for (i=0; i<MAX_TEXTURE_UNITS; i++)
1158       init_texture_unit( ctx, i );
1159    ctx->Texture.SharedPalette = GL_FALSE;
1160    _mesa_init_colortable(&ctx->Texture.Palette);
1161
1162    /* Transformation group */
1163    ctx->Transform.MatrixMode = GL_MODELVIEW;
1164    ctx->Transform.Normalize = GL_FALSE;
1165    ctx->Transform.RescaleNormals = GL_FALSE;
1166    for (i=0;i<MAX_CLIP_PLANES;i++) {
1167       ctx->Transform.ClipEnabled[i] = GL_FALSE;
1168       ASSIGN_4V( ctx->Transform.EyeUserPlane[i], 0.0, 0.0, 0.0, 0.0 );
1169    }
1170    ctx->Transform.AnyClip = GL_FALSE;
1171
1172    /* Viewport group */
1173    ctx->Viewport.X = 0;
1174    ctx->Viewport.Y = 0;
1175    ctx->Viewport.Width = 0;
1176    ctx->Viewport.Height = 0;
1177    ctx->Viewport.Near = 0.0;
1178    ctx->Viewport.Far = 1.0;
1179    gl_matrix_ctr(&ctx->Viewport.WindowMap);
1180
1181 #define Sz 10
1182 #define Tz 14
1183    ctx->Viewport.WindowMap.m[Sz] = 0.5 * ctx->Visual->DepthMaxF;
1184    ctx->Viewport.WindowMap.m[Tz] = 0.5 * ctx->Visual->DepthMaxF;
1185 #undef Sz
1186 #undef Tz
1187
1188    ctx->Viewport.WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
1189    ctx->Viewport.WindowMap.type = MATRIX_3D_NO_ROT;
1190
1191    /* Vertex arrays */
1192    ctx->Array.Vertex.Size = 4;
1193    ctx->Array.Vertex.Type = GL_FLOAT;
1194    ctx->Array.Vertex.Stride = 0;
1195    ctx->Array.Vertex.StrideB = 0;
1196    ctx->Array.Vertex.Ptr = NULL;
1197    ctx->Array.Vertex.Enabled = GL_FALSE;
1198    ctx->Array.Normal.Type = GL_FLOAT;
1199    ctx->Array.Normal.Stride = 0;
1200    ctx->Array.Normal.StrideB = 0;
1201    ctx->Array.Normal.Ptr = NULL;
1202    ctx->Array.Normal.Enabled = GL_FALSE;
1203    ctx->Array.Color.Size = 4;
1204    ctx->Array.Color.Type = GL_FLOAT;
1205    ctx->Array.Color.Stride = 0;
1206    ctx->Array.Color.StrideB = 0;
1207    ctx->Array.Color.Ptr = NULL;
1208    ctx->Array.Color.Enabled = GL_FALSE;
1209    ctx->Array.Index.Type = GL_FLOAT;
1210    ctx->Array.Index.Stride = 0;
1211    ctx->Array.Index.StrideB = 0;
1212    ctx->Array.Index.Ptr = NULL;
1213    ctx->Array.Index.Enabled = GL_FALSE;
1214    for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1215       ctx->Array.TexCoord[i].Size = 4;
1216       ctx->Array.TexCoord[i].Type = GL_FLOAT;
1217       ctx->Array.TexCoord[i].Stride = 0;
1218       ctx->Array.TexCoord[i].StrideB = 0;
1219       ctx->Array.TexCoord[i].Ptr = NULL;
1220       ctx->Array.TexCoord[i].Enabled = GL_FALSE;
1221    }
1222    ctx->Array.TexCoordInterleaveFactor = 1;
1223    ctx->Array.EdgeFlag.Stride = 0;
1224    ctx->Array.EdgeFlag.StrideB = 0;
1225    ctx->Array.EdgeFlag.Ptr = NULL;
1226    ctx->Array.EdgeFlag.Enabled = GL_FALSE;
1227    ctx->Array.ActiveTexture = 0;   /* GL_ARB_multitexture */
1228
1229    /* Pixel transfer */
1230    ctx->Pack.Alignment = 4;
1231    ctx->Pack.RowLength = 0;
1232    ctx->Pack.ImageHeight = 0;
1233    ctx->Pack.SkipPixels = 0;
1234    ctx->Pack.SkipRows = 0;
1235    ctx->Pack.SkipImages = 0;
1236    ctx->Pack.SwapBytes = GL_FALSE;
1237    ctx->Pack.LsbFirst = GL_FALSE;
1238    ctx->Unpack.Alignment = 4;
1239    ctx->Unpack.RowLength = 0;
1240    ctx->Unpack.ImageHeight = 0;
1241    ctx->Unpack.SkipPixels = 0;
1242    ctx->Unpack.SkipRows = 0;
1243    ctx->Unpack.SkipImages = 0;
1244    ctx->Unpack.SwapBytes = GL_FALSE;
1245    ctx->Unpack.LsbFirst = GL_FALSE;
1246
1247    /* Feedback */
1248    ctx->Feedback.Type = GL_2D;   /* TODO: verify */
1249    ctx->Feedback.Buffer = NULL;
1250    ctx->Feedback.BufferSize = 0;
1251    ctx->Feedback.Count = 0;
1252
1253    /* Selection/picking */
1254    ctx->Select.Buffer = NULL;
1255    ctx->Select.BufferSize = 0;
1256    ctx->Select.BufferCount = 0;
1257    ctx->Select.Hits = 0;
1258    ctx->Select.NameStackDepth = 0;
1259
1260    /* Optimized Accum buffer */
1261    ctx->IntegerAccumMode = GL_TRUE;
1262    ctx->IntegerAccumScaler = 0.0;
1263
1264    /* Renderer and client attribute stacks */
1265    ctx->AttribStackDepth = 0;
1266    ctx->ClientAttribStackDepth = 0;
1267
1268    /* Display list */
1269    ctx->CallDepth = 0;
1270    ctx->ExecuteFlag = GL_TRUE;
1271    ctx->CompileFlag = GL_FALSE;
1272    ctx->CurrentListPtr = NULL;
1273    ctx->CurrentBlock = NULL;
1274    ctx->CurrentListNum = 0;
1275    ctx->CurrentPos = 0;
1276
1277    /* Color tables */
1278    _mesa_init_colortable(&ctx->ColorTable);
1279    _mesa_init_colortable(&ctx->ProxyColorTable);
1280    _mesa_init_colortable(&ctx->PostConvolutionColorTable);
1281    _mesa_init_colortable(&ctx->ProxyPostConvolutionColorTable);
1282    _mesa_init_colortable(&ctx->PostColorMatrixColorTable);
1283    _mesa_init_colortable(&ctx->ProxyPostColorMatrixColorTable);
1284
1285    /* Miscellaneous */
1286    ctx->NewState = NEW_ALL;
1287    ctx->RenderMode = GL_RENDER;
1288    ctx->StippleCounter = 0;
1289    ctx->NeedNormals = GL_FALSE;
1290    ctx->DoViewportMapping = GL_TRUE;
1291    ctx->ImageTransferState = UPDATE_IMAGE_TRANSFER_STATE;
1292
1293    ctx->NeedEyeCoords = GL_FALSE;
1294    ctx->NeedEyeNormals = GL_FALSE;
1295    ctx->vb_proj_matrix = &ctx->ModelProjectMatrix;
1296
1297    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1298
1299    ctx->CatchSignals = GL_TRUE;
1300    ctx->OcclusionResult = GL_FALSE;
1301    ctx->OcclusionResultSaved = GL_FALSE;
1302
1303    /* For debug/development only */
1304    ctx->NoRaster = getenv("MESA_NO_RASTER") ? GL_TRUE : GL_FALSE;
1305    ctx->FirstTimeCurrent = GL_TRUE;
1306
1307    /* Dither disable */
1308    ctx->NoDither = getenv("MESA_NO_DITHER") ? GL_TRUE : GL_FALSE;
1309    if (ctx->NoDither) {
1310       if (getenv("MESA_DEBUG")) {
1311          fprintf(stderr, "MESA_NO_DITHER set - dithering disabled\n");
1312       }
1313       ctx->Color.DitherFlag = GL_FALSE;
1314    }
1315 }
1316
1317
1318
1319
1320 /*
1321  * Allocate the proxy textures.  If we run out of memory part way through
1322  * the allocations clean up and return GL_FALSE.
1323  * Return:  GL_TRUE=success, GL_FALSE=failure
1324  */
1325 static GLboolean
1326 alloc_proxy_textures( GLcontext *ctx )
1327 {
1328    GLboolean out_of_memory;
1329    GLint i;
1330
1331    ctx->Texture.Proxy1D = gl_alloc_texture_object(NULL, 0, 1);
1332    if (!ctx->Texture.Proxy1D) {
1333       return GL_FALSE;
1334    }
1335
1336    ctx->Texture.Proxy2D = gl_alloc_texture_object(NULL, 0, 2);
1337    if (!ctx->Texture.Proxy2D) {
1338       gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
1339       return GL_FALSE;
1340    }
1341
1342    ctx->Texture.Proxy3D = gl_alloc_texture_object(NULL, 0, 3);
1343    if (!ctx->Texture.Proxy3D) {
1344       gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
1345       gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
1346       return GL_FALSE;
1347    }
1348
1349    out_of_memory = GL_FALSE;
1350    for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1351       ctx->Texture.Proxy1D->Image[i] = _mesa_alloc_texture_image();
1352       ctx->Texture.Proxy2D->Image[i] = _mesa_alloc_texture_image();
1353       ctx->Texture.Proxy3D->Image[i] = _mesa_alloc_texture_image();
1354       if (!ctx->Texture.Proxy1D->Image[i]
1355           || !ctx->Texture.Proxy2D->Image[i]
1356           || !ctx->Texture.Proxy3D->Image[i]) {
1357          out_of_memory = GL_TRUE;
1358       }
1359    }
1360    if (out_of_memory) {
1361       for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1362          if (ctx->Texture.Proxy1D->Image[i]) {
1363             _mesa_free_texture_image(ctx->Texture.Proxy1D->Image[i]);
1364          }
1365          if (ctx->Texture.Proxy2D->Image[i]) {
1366             _mesa_free_texture_image(ctx->Texture.Proxy2D->Image[i]);
1367          }
1368          if (ctx->Texture.Proxy3D->Image[i]) {
1369             _mesa_free_texture_image(ctx->Texture.Proxy3D->Image[i]);
1370          }
1371       }
1372       gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
1373       gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
1374       gl_free_texture_object(NULL, ctx->Texture.Proxy3D);
1375       return GL_FALSE;
1376    }
1377    else {
1378       return GL_TRUE;
1379    }
1380 }
1381
1382
1383
1384 /*
1385  * Initialize a GLcontext struct.  This includes allocating all the
1386  * other structs and arrays which hang off of the context by pointers.
1387  */
1388 GLboolean
1389 _mesa_initialize_context( GLcontext *ctx,
1390                           GLvisual *visual,
1391                           GLcontext *share_list,
1392                           void *driver_ctx,
1393                           GLboolean direct )
1394 {
1395    GLuint dispatchSize;
1396
1397    (void) direct;  /* not used */
1398
1399    /* misc one-time initializations */
1400    one_time_init();
1401
1402    ctx->DriverCtx = driver_ctx;
1403    ctx->Visual = visual;
1404    ctx->DrawBuffer = NULL;
1405    ctx->ReadBuffer = NULL;
1406
1407    ctx->VB = gl_vb_create_for_immediate( ctx );
1408    if (!ctx->VB) {
1409       return GL_FALSE;
1410    }
1411    ctx->input = ctx->VB->IM;
1412
1413    ctx->PB = gl_alloc_pb();
1414    if (!ctx->PB) {
1415       ALIGN_FREE( ctx->VB );
1416       return GL_FALSE;
1417    }
1418
1419    if (share_list) {
1420       /* share the group of display lists of another context */
1421       ctx->Shared = share_list->Shared;
1422    }
1423    else {
1424       /* allocate new group of display lists */
1425       ctx->Shared = alloc_shared_state();
1426       if (!ctx->Shared) {
1427          ALIGN_FREE( ctx->VB );
1428          FREE( ctx->PB );
1429          return GL_FALSE;
1430       }
1431    }
1432    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1433    ctx->Shared->RefCount++;
1434    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1435
1436    init_attrib_groups( ctx );
1437
1438    gl_reset_vb( ctx->VB );
1439    gl_reset_input( ctx );
1440
1441    if (visual->DBflag) {
1442       ctx->Color.DrawBuffer = GL_BACK;
1443       ctx->Color.DriverDrawBuffer = GL_BACK_LEFT;
1444       ctx->Color.DrawDestMask = BACK_LEFT_BIT;
1445       ctx->Pixel.ReadBuffer = GL_BACK;
1446       ctx->Pixel.DriverReadBuffer = GL_BACK_LEFT;
1447    }
1448    else {
1449       ctx->Color.DrawBuffer = GL_FRONT;
1450       ctx->Color.DriverDrawBuffer = GL_FRONT_LEFT;
1451       ctx->Color.DrawDestMask = FRONT_LEFT_BIT;
1452       ctx->Pixel.ReadBuffer = GL_FRONT;
1453       ctx->Pixel.DriverReadBuffer = GL_FRONT_LEFT;
1454    }
1455
1456    if (!alloc_proxy_textures(ctx)) {
1457       free_shared_state(ctx, ctx->Shared);
1458       ALIGN_FREE( ctx->VB );
1459       FREE( ctx->PB );
1460       return GL_FALSE;
1461    }
1462
1463    /* register the most recent extension functions with libGL */
1464    _glapi_add_entrypoint("glTbufferMask3DFX", 553);
1465    _glapi_add_entrypoint("glCompressedTexImage3DARB", 554);
1466    _glapi_add_entrypoint("glCompressedTexImage2DARB", 555);
1467    _glapi_add_entrypoint("glCompressedTexImage1DARB", 556);
1468    _glapi_add_entrypoint("glCompressedTexSubImage3DARB", 557);
1469    _glapi_add_entrypoint("glCompressedTexSubImage2DARB", 558);
1470    _glapi_add_entrypoint("glCompressedTexSubImage1DARB", 559);
1471    _glapi_add_entrypoint("glGetCompressedTexImageARB", 560);
1472
1473    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1474     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
1475     * Mesa we do this to accomodate different versions of libGL and various
1476     * DRI drivers.
1477     */
1478    dispatchSize = MAX2(_glapi_get_dispatch_table_size(),
1479                        sizeof(struct _glapi_table) / sizeof(void *));
1480
1481    /* setup API dispatch tables */
1482    ctx->Exec = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
1483    ctx->Save = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
1484    if (!ctx->Exec || !ctx->Save) {
1485       free_shared_state(ctx, ctx->Shared);
1486       ALIGN_FREE( ctx->VB );
1487       FREE( ctx->PB );
1488       if (ctx->Exec)
1489          FREE( ctx->Exec );
1490    }
1491    _mesa_init_exec_table(ctx->Exec, dispatchSize);
1492    _mesa_init_dlist_table(ctx->Save, dispatchSize);
1493    ctx->CurrentDispatch = ctx->Exec;
1494
1495 #if defined(GL_MESA_TRACE)
1496    ctx->TraceCtx = CALLOC( sizeof(trace_context_t) );
1497 #if 0
1498    /* Brian: do you want to have CreateContext fail here,
1499        or should we just trap in NewTrace (currently done)? */
1500    if (!(ctx->TraceCtx)) {
1501       free_shared_state(ctx, ctx->Shared);
1502       ALIGN_FREE( ctx->VB );
1503       FREE( ctx->PB );
1504       FREE( ctx->Exec );
1505       FREE( ctx->Save );
1506       return GL_FALSE;
1507    }
1508 #endif
1509    trInitContext(ctx->TraceCtx);
1510
1511    ctx->TraceDispatch = (struct _glapi_table *)
1512                         CALLOC(dispatchSize * sizeof(void*));
1513 #if 0
1514    if (!(ctx->TraceCtx)) {
1515       free_shared_state(ctx, ctx->Shared);
1516       ALIGN_FREE( ctx->VB );
1517       FREE( ctx->PB );
1518       FREE( ctx->Exec );
1519       FREE( ctx->Save );
1520       FREE( ctx->TraceCtx );
1521       return GL_FALSE;
1522    }
1523 #endif
1524    trInitDispatch(ctx->TraceDispatch);
1525 #endif
1526
1527    return GL_TRUE;
1528 }
1529
1530
1531
1532 /*
1533  * Allocate and initialize a GLcontext structure.
1534  * Input:  visual - a GLvisual pointer
1535  *         sharelist - another context to share display lists with or NULL
1536  *         driver_ctx - pointer to device driver's context state struct
1537  * Return:  pointer to a new gl_context struct or NULL if error.
1538  */
1539 GLcontext *
1540 gl_create_context( GLvisual *visual,
1541                    GLcontext *share_list,
1542                    void *driver_ctx,
1543                    GLboolean direct )
1544 {
1545    GLcontext *ctx = (GLcontext *) CALLOC( sizeof(GLcontext) );
1546    if (!ctx) {
1547       return NULL;
1548    }
1549
1550    if (_mesa_initialize_context(ctx, visual, share_list, driver_ctx, direct)) {
1551       return ctx;
1552    }
1553    else {
1554       FREE(ctx);
1555       return NULL;
1556    }
1557 }
1558
1559
1560
1561 /*
1562  * Free the data associated with the given context.
1563  * But don't free() the GLcontext struct itself!
1564  */
1565 void
1566 gl_free_context_data( GLcontext *ctx )
1567 {
1568    struct gl_shine_tab *s, *tmps;
1569    GLuint i, j;
1570
1571    /* if we're destroying the current context, unbind it first */
1572    if (ctx == gl_get_current_context()) {
1573       gl_make_current(NULL, NULL);
1574    }
1575
1576    gl_matrix_dtr( &ctx->ModelView );
1577    for (i = 0; i < MAX_MODELVIEW_STACK_DEPTH - 1; i++) {
1578       gl_matrix_dtr( &ctx->ModelViewStack[i] );
1579    }
1580    gl_matrix_dtr( &ctx->ProjectionMatrix );
1581    for (i = 0; i < MAX_PROJECTION_STACK_DEPTH - 1; i++) {
1582       gl_matrix_dtr( &ctx->ProjectionStack[i] );
1583    }
1584    for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1585       gl_matrix_dtr( &ctx->TextureMatrix[i] );
1586       for (j = 0; j < MAX_TEXTURE_STACK_DEPTH - 1; j++) {
1587          gl_matrix_dtr( &ctx->TextureStack[i][j] );
1588       }
1589    }
1590
1591    FREE( ctx->PB );
1592
1593    if (ctx->input != ctx->VB->IM)
1594       gl_immediate_free( ctx->input );
1595
1596    gl_vb_free( ctx->VB );
1597
1598    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1599    ctx->Shared->RefCount--;
1600    assert(ctx->Shared->RefCount >= 0);
1601    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1602    if (ctx->Shared->RefCount == 0) {
1603       /* free shared state */
1604       free_shared_state( ctx, ctx->Shared );
1605    }
1606
1607    foreach_s( s, tmps, ctx->ShineTabList ) {
1608       FREE( s );
1609    }
1610    FREE( ctx->ShineTabList );
1611
1612    /* Free proxy texture objects */
1613    gl_free_texture_object( NULL, ctx->Texture.Proxy1D );
1614    gl_free_texture_object( NULL, ctx->Texture.Proxy2D );
1615    gl_free_texture_object( NULL, ctx->Texture.Proxy3D );
1616
1617    /* Free evaluator data */
1618    if (ctx->EvalMap.Map1Vertex3.Points)
1619       FREE( ctx->EvalMap.Map1Vertex3.Points );
1620    if (ctx->EvalMap.Map1Vertex4.Points)
1621       FREE( ctx->EvalMap.Map1Vertex4.Points );
1622    if (ctx->EvalMap.Map1Index.Points)
1623       FREE( ctx->EvalMap.Map1Index.Points );
1624    if (ctx->EvalMap.Map1Color4.Points)
1625       FREE( ctx->EvalMap.Map1Color4.Points );
1626    if (ctx->EvalMap.Map1Normal.Points)
1627       FREE( ctx->EvalMap.Map1Normal.Points );
1628    if (ctx->EvalMap.Map1Texture1.Points)
1629       FREE( ctx->EvalMap.Map1Texture1.Points );
1630    if (ctx->EvalMap.Map1Texture2.Points)
1631       FREE( ctx->EvalMap.Map1Texture2.Points );
1632    if (ctx->EvalMap.Map1Texture3.Points)
1633       FREE( ctx->EvalMap.Map1Texture3.Points );
1634    if (ctx->EvalMap.Map1Texture4.Points)
1635       FREE( ctx->EvalMap.Map1Texture4.Points );
1636
1637    if (ctx->EvalMap.Map2Vertex3.Points)
1638       FREE( ctx->EvalMap.Map2Vertex3.Points );
1639    if (ctx->EvalMap.Map2Vertex4.Points)
1640       FREE( ctx->EvalMap.Map2Vertex4.Points );
1641    if (ctx->EvalMap.Map2Index.Points)
1642       FREE( ctx->EvalMap.Map2Index.Points );
1643    if (ctx->EvalMap.Map2Color4.Points)
1644       FREE( ctx->EvalMap.Map2Color4.Points );
1645    if (ctx->EvalMap.Map2Normal.Points)
1646       FREE( ctx->EvalMap.Map2Normal.Points );
1647    if (ctx->EvalMap.Map2Texture1.Points)
1648       FREE( ctx->EvalMap.Map2Texture1.Points );
1649    if (ctx->EvalMap.Map2Texture2.Points)
1650       FREE( ctx->EvalMap.Map2Texture2.Points );
1651    if (ctx->EvalMap.Map2Texture3.Points)
1652       FREE( ctx->EvalMap.Map2Texture3.Points );
1653    if (ctx->EvalMap.Map2Texture4.Points)
1654       FREE( ctx->EvalMap.Map2Texture4.Points );
1655
1656    _mesa_free_colortable_data( &ctx->ColorTable );
1657    _mesa_free_colortable_data( &ctx->PostConvolutionColorTable );
1658    _mesa_free_colortable_data( &ctx->PostColorMatrixColorTable );
1659    _mesa_free_colortable_data( &ctx->Texture.Palette );
1660
1661    /* Free cache of immediate buffers. */
1662    while (ctx->nr_im_queued-- > 0) {
1663       struct immediate * next = ctx->freed_im_queue->next;
1664       ALIGN_FREE( ctx->freed_im_queue );
1665       ctx->freed_im_queue = next;
1666    }
1667    gl_extensions_dtr(ctx);
1668
1669    FREE(ctx->Exec);
1670    FREE(ctx->Save);
1671 }
1672
1673
1674
1675 /*
1676  * Destroy a GLcontext structure.
1677  */
1678 void
1679 gl_destroy_context( GLcontext *ctx )
1680 {
1681    if (ctx) {
1682       gl_free_context_data(ctx);
1683       FREE( (void *) ctx );
1684    }
1685 }
1686
1687
1688
1689 /*
1690  * Called by the driver after both the context and driver are fully
1691  * initialized.  Currently just reads the config file.
1692  */
1693 void
1694 gl_context_initialize( GLcontext *ctx )
1695 {
1696    gl_read_config_file( ctx );
1697 }
1698
1699
1700
1701 /*
1702  * Copy attribute groups from one context to another.
1703  * Input:  src - source context
1704  *         dst - destination context
1705  *         mask - bitwise OR of GL_*_BIT flags
1706  */
1707 void
1708 gl_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1709 {
1710    if (mask & GL_ACCUM_BUFFER_BIT) {
1711       MEMCPY( &dst->Accum, &src->Accum, sizeof(struct gl_accum_attrib) );
1712    }
1713    if (mask & GL_COLOR_BUFFER_BIT) {
1714       MEMCPY( &dst->Color, &src->Color, sizeof(struct gl_colorbuffer_attrib) );
1715    }
1716    if (mask & GL_CURRENT_BIT) {
1717       MEMCPY( &dst->Current, &src->Current, sizeof(struct gl_current_attrib) );
1718    }
1719    if (mask & GL_DEPTH_BUFFER_BIT) {
1720       MEMCPY( &dst->Depth, &src->Depth, sizeof(struct gl_depthbuffer_attrib) );
1721    }
1722    if (mask & GL_ENABLE_BIT) {
1723       /* no op */
1724    }
1725    if (mask & GL_EVAL_BIT) {
1726       MEMCPY( &dst->Eval, &src->Eval, sizeof(struct gl_eval_attrib) );
1727    }
1728    if (mask & GL_FOG_BIT) {
1729       MEMCPY( &dst->Fog, &src->Fog, sizeof(struct gl_fog_attrib) );
1730    }
1731    if (mask & GL_HINT_BIT) {
1732       MEMCPY( &dst->Hint, &src->Hint, sizeof(struct gl_hint_attrib) );
1733    }
1734    if (mask & GL_LIGHTING_BIT) {
1735       MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light_attrib) );
1736       /*       gl_reinit_light_attrib( &dst->Light ); */
1737    }
1738    if (mask & GL_LINE_BIT) {
1739       MEMCPY( &dst->Line, &src->Line, sizeof(struct gl_line_attrib) );
1740    }
1741    if (mask & GL_LIST_BIT) {
1742       MEMCPY( &dst->List, &src->List, sizeof(struct gl_list_attrib) );
1743    }
1744    if (mask & GL_PIXEL_MODE_BIT) {
1745       MEMCPY( &dst->Pixel, &src->Pixel, sizeof(struct gl_pixel_attrib) );
1746    }
1747    if (mask & GL_POINT_BIT) {
1748       MEMCPY( &dst->Point, &src->Point, sizeof(struct gl_point_attrib) );
1749    }
1750    if (mask & GL_POLYGON_BIT) {
1751       MEMCPY( &dst->Polygon, &src->Polygon, sizeof(struct gl_polygon_attrib) );
1752    }
1753    if (mask & GL_POLYGON_STIPPLE_BIT) {
1754       /* Use loop instead of MEMCPY due to problem with Portland Group's
1755        * C compiler.  Reported by John Stone.
1756        */
1757       int i;
1758       for (i=0;i<32;i++) {
1759          dst->PolygonStipple[i] = src->PolygonStipple[i];
1760       }
1761    }
1762    if (mask & GL_SCISSOR_BIT) {
1763       MEMCPY( &dst->Scissor, &src->Scissor, sizeof(struct gl_scissor_attrib) );
1764    }
1765    if (mask & GL_STENCIL_BUFFER_BIT) {
1766       MEMCPY( &dst->Stencil, &src->Stencil, sizeof(struct gl_stencil_attrib) );
1767    }
1768    if (mask & GL_TEXTURE_BIT) {
1769       MEMCPY( &dst->Texture, &src->Texture, sizeof(struct gl_texture_attrib) );
1770    }
1771    if (mask & GL_TRANSFORM_BIT) {
1772       MEMCPY( &dst->Transform, &src->Transform, sizeof(struct gl_transform_attrib) );
1773    }
1774    if (mask & GL_VIEWPORT_BIT) {
1775       MEMCPY( &dst->Viewport, &src->Viewport, sizeof(struct gl_viewport_attrib) );
1776    }
1777 }
1778
1779
1780 /*
1781  * Set the current context, binding the given frame buffer to the context.
1782  */
1783 void gl_make_current( GLcontext *newCtx, GLframebuffer *buffer )
1784 {
1785    gl_make_current2( newCtx, buffer, buffer );
1786 }
1787
1788
1789 /*
1790  * Bind the given context to the given draw-buffer and read-buffer
1791  * and make it the current context for this thread.
1792  */
1793 void gl_make_current2( GLcontext *newCtx, GLframebuffer *drawBuffer,
1794                        GLframebuffer *readBuffer )
1795 {
1796 #if 0
1797    GLcontext *oldCtx = gl_get_context();
1798
1799    /* Flush the old context
1800     */
1801    if (oldCtx) {
1802       ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(oldCtx, "gl_make_current");
1803
1804       /* unbind frame buffers from context */
1805       if (oldCtx->DrawBuffer) {
1806          oldCtx->DrawBuffer = NULL;
1807       }
1808       if (oldCtx->ReadBuffer) {
1809          oldCtx->ReadBuffer = NULL;
1810       }
1811    }
1812 #endif
1813
1814    /* We call this function periodically (just here for now) in
1815     * order to detect when multithreading has begun.
1816     */
1817    _glapi_check_multithread();
1818
1819    _glapi_set_context((void *) newCtx);
1820    ASSERT(gl_get_current_context() == newCtx);
1821    if (newCtx) {
1822       SET_IMMEDIATE(newCtx, newCtx->input);
1823       _glapi_set_dispatch(newCtx->CurrentDispatch);
1824    }
1825    else {
1826       _glapi_set_dispatch(NULL);  /* none current */
1827    }
1828
1829    if (MESA_VERBOSE) fprintf(stderr, "gl_make_current()\n");
1830
1831    if (newCtx && drawBuffer && readBuffer) {
1832       /* TODO: check if newCtx and buffer's visual match??? */
1833       newCtx->DrawBuffer = drawBuffer;
1834       newCtx->ReadBuffer = readBuffer;
1835       newCtx->NewState = NEW_ALL;   /* just to be safe */
1836       gl_update_state( newCtx );
1837    }
1838
1839    /* We can use this to help debug user's problems.  Tell the to set
1840     * the MESA_INFO env variable before running their app.  Then the
1841     * first time each context is made current we'll print some useful
1842     * information.
1843     */
1844    if (newCtx && newCtx->FirstTimeCurrent) {
1845       if (getenv("MESA_INFO")) {
1846          fprintf(stderr, "Mesa GL_VERSION = %s\n", (char *) _mesa_GetString(GL_VERSION));
1847          fprintf(stderr, "Mesa GL_RENDERER = %s\n", (char *) _mesa_GetString(GL_RENDERER));
1848          fprintf(stderr, "Mesa GL_VENDOR = %s\n", (char *) _mesa_GetString(GL_VENDOR));
1849          fprintf(stderr, "Mesa GL_EXTENSIONS = %s\n", (char *) _mesa_GetString(GL_EXTENSIONS));
1850 #if defined(THREADS)
1851          fprintf(stderr, "Mesa thread-safe: YES\n");
1852 #else
1853          fprintf(stderr, "Mesa thread-safe: NO\n");
1854 #endif
1855 #if defined(USE_X86_ASM)
1856          fprintf(stderr, "Mesa x86-optimized: YES\n");
1857 #else
1858          fprintf(stderr, "Mesa x86-optimized: NO\n");
1859 #endif
1860       }
1861       newCtx->FirstTimeCurrent = GL_FALSE;
1862    }
1863 }
1864
1865
1866
1867 /*
1868  * Return current context handle for the calling thread.
1869  * This isn't the fastest way to get the current context.
1870  * If you need speed, see the GET_CURRENT_CONTEXT() macro in context.h
1871  */
1872 GLcontext *gl_get_current_context( void )
1873 {
1874    return (GLcontext *) _glapi_get_context();
1875 }
1876
1877
1878
1879 /*
1880  * This should be called by device drivers just before they do a
1881  * swapbuffers.  Any pending rendering commands will be executed.
1882  */
1883 void
1884 _mesa_swapbuffers(GLcontext *ctx)
1885 {
1886    FLUSH_VB( ctx, "swap buffers" );
1887 }
1888
1889
1890
1891 /*
1892  * Return pointer to this context's current API dispatch table.
1893  * It'll either be the immediate-mode execute dispatcher or the
1894  * display list compile dispatcher.
1895  */
1896 struct _glapi_table *
1897 _mesa_get_dispatch(GLcontext *ctx)
1898 {
1899    return ctx->CurrentDispatch;
1900 }
1901
1902
1903
1904 /**********************************************************************/
1905 /*****                Miscellaneous functions                     *****/
1906 /**********************************************************************/
1907
1908
1909 /*
1910  * This function is called when the Mesa user has stumbled into a code
1911  * path which may not be implemented fully or correctly.
1912  */
1913 void gl_problem( const GLcontext *ctx, const char *s )
1914 {
1915    fprintf( stderr, "Mesa implementation error: %s\n", s );
1916    fprintf( stderr, "Report to Mesa bug database at www.mesa3d.org\n" );
1917    (void) ctx;
1918 }
1919
1920
1921
1922 /*
1923  * This is called to inform the user that he or she has tried to do
1924  * something illogical or if there's likely a bug in their program
1925  * (like enabled depth testing without a depth buffer).
1926  */
1927 void gl_warning( const GLcontext *ctx, const char *s )
1928 {
1929    GLboolean debug;
1930 #ifdef DEBUG
1931    debug = GL_TRUE;
1932 #else
1933    if (getenv("MESA_DEBUG")) {
1934       debug = GL_TRUE;
1935    }
1936    else {
1937       debug = GL_FALSE;
1938    }
1939 #endif
1940    if (debug) {
1941       fprintf( stderr, "Mesa warning: %s\n", s );
1942    }
1943    (void) ctx;
1944 }
1945
1946
1947
1948 /*
1949  * Compile an error into current display list.
1950  */
1951 void gl_compile_error( GLcontext *ctx, GLenum error, const char *s )
1952 {
1953    if (ctx->CompileFlag)
1954       gl_save_error( ctx, error, s );
1955
1956    if (ctx->ExecuteFlag)
1957       gl_error( ctx, error, s );
1958 }
1959
1960
1961
1962 /*
1963  * This is Mesa's error handler.  Normally, all that's done is the updating
1964  * of the current error value.  If Mesa is compiled with -DDEBUG or if the
1965  * environment variable "MESA_DEBUG" is defined then a real error message
1966  * is printed to stderr.
1967  * Input:  ctx - the GL context
1968  *         error - the error value
1969  *         where - usually the name of function where error was detected
1970  */
1971 void
1972 gl_error( GLcontext *ctx, GLenum error, const char *where )
1973 {
1974    const char *debugEnv = getenv("MESA_DEBUG");
1975    GLboolean debug;
1976
1977 #ifdef DEBUG
1978    if (debugEnv && strstr(debugEnv, "silent"))
1979       debug = GL_FALSE;
1980    else
1981       debug = GL_TRUE;
1982 #else
1983    if (debugEnv)
1984       debug = GL_TRUE;
1985    else
1986       debug = GL_FALSE;
1987 #endif
1988
1989    if (debug) {
1990       const char *errstr;
1991       switch (error) {
1992          case GL_NO_ERROR:
1993             errstr = "GL_NO_ERROR";
1994             break;
1995          case GL_INVALID_VALUE:
1996             errstr = "GL_INVALID_VALUE";
1997             break;
1998          case GL_INVALID_ENUM:
1999             errstr = "GL_INVALID_ENUM";
2000             break;
2001          case GL_INVALID_OPERATION:
2002             errstr = "GL_INVALID_OPERATION";
2003             break;
2004          case GL_STACK_OVERFLOW:
2005             errstr = "GL_STACK_OVERFLOW";
2006             break;
2007          case GL_STACK_UNDERFLOW:
2008             errstr = "GL_STACK_UNDERFLOW";
2009             break;
2010          case GL_OUT_OF_MEMORY:
2011             errstr = "GL_OUT_OF_MEMORY";
2012             break;
2013          case GL_TABLE_TOO_LARGE:
2014             errstr = "GL_TABLE_TOO_LARGE";
2015             break;
2016          default:
2017             errstr = "unknown";
2018             break;
2019       }
2020       fprintf(stderr, "Mesa user error: %s in %s\n", errstr, where);
2021    }
2022
2023    if (ctx->ErrorValue == GL_NO_ERROR) {
2024       ctx->ErrorValue = error;
2025    }
2026
2027    /* Call device driver's error handler, if any.  This is used on the Mac. */
2028    if (ctx->Driver.Error) {
2029       (*ctx->Driver.Error)( ctx );
2030    }
2031 }
2032
2033
2034
2035 void
2036 _mesa_Finish( void )
2037 {
2038    GET_CURRENT_CONTEXT(ctx);
2039    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glFinish");
2040    if (ctx->Driver.Finish) {
2041       (*ctx->Driver.Finish)( ctx );
2042    }
2043 }
2044
2045
2046
2047 void
2048 _mesa_Flush( void )
2049 {
2050    GET_CURRENT_CONTEXT(ctx);
2051    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glFlush");
2052    if (ctx->Driver.Flush) {
2053       (*ctx->Driver.Flush)( ctx );
2054    }
2055 }
2056
2057
2058
2059 const char *_mesa_prim_name[GL_POLYGON+2] = {
2060    "GL_POINTS",
2061    "GL_LINES",
2062    "GL_LINE_LOOP",
2063    "GL_LINE_STRIP",
2064    "GL_TRIANGLES",
2065    "GL_TRIANGLE_STRIP",
2066    "GL_TRIANGLE_FAN",
2067    "GL_QUADS",
2068    "GL_QUAD_STRIP",
2069    "GL_POLYGON",
2070    "culled primitive"
2071 };
2072