src/mesa/main/context.c

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