src/mesa/main/context.c

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