src/mesa/main/context.c

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