src/mesa/main/context.c

   1 /* $Id: context.c,v 1.71 2000/06/27 04:29:22 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    ss->DefaultCubeMap = gl_alloc_texture_object(ss, 0, 6);
 471    if (!ss->DefaultCubeMap) {
 472       outOfMemory = GL_TRUE;
 473    }
 474    else {
 475       ss->DefaultCubeMap->RefCount++;
 476    }
 477
 478    if (!ss->DisplayList || !ss->TexObjects || outOfMemory) {
 479       /* Ran out of memory at some point.  Free everything and return NULL */
 480       if (ss->DisplayList)
 481          _mesa_DeleteHashTable(ss->DisplayList);
 482       if (ss->TexObjects)
 483          _mesa_DeleteHashTable(ss->TexObjects);
 484       if (ss->DefaultD[1])
 485          gl_free_texture_object(ss, ss->DefaultD[1]);
 486       if (ss->DefaultD[2])
 487          gl_free_texture_object(ss, ss->DefaultD[2]);
 488       if (ss->DefaultD[3])
 489          gl_free_texture_object(ss, ss->DefaultD[3]);
 490       if (ss->DefaultCubeMap)
 491          gl_free_texture_object(ss, ss->DefaultCubeMap);
 492       FREE(ss);
 493       return NULL;
 494    }
 495    else {
 496       return ss;
 497    }
 498 }
 499
 500
 501 /*
 502  * Deallocate a shared state context and all children structures.
 503  */
 504 static void
 505 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
 506 {
 507    /* Free display lists */
 508    while (1) {
 509       GLuint list = _mesa_HashFirstEntry(ss->DisplayList);
 510       if (list) {
 511          gl_destroy_list(ctx, list);
 512       }
 513       else {
 514          break;
 515       }
 516    }
 517    _mesa_DeleteHashTable(ss->DisplayList);
 518
 519    /* Free texture objects */
 520    while (ss->TexObjectList)
 521    {
 522       if (ctx->Driver.DeleteTexture)
 523          (*ctx->Driver.DeleteTexture)( ctx, ss->TexObjectList );
 524       /* this function removes from linked list too! */
 525       gl_free_texture_object(ss, ss->TexObjectList);
 526    }
 527    _mesa_DeleteHashTable(ss->TexObjects);
 528
 529    FREE(ss);
 530 }
 531
 532
 533
 534 /*
 535  * Initialize the nth light.  Note that the defaults for light 0 are
 536  * different than the other lights.
 537  */
 538 static void
 539 init_light( struct gl_light *l, GLuint n )
 540 {
 541    make_empty_list( l );
 542
 543    ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 );
 544    if (n==0) {
 545       ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 );
 546       ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 );
 547    }
 548    else {
 549       ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 );
 550       ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 );
 551    }
 552    ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 );
 553    ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 );
 554    l->SpotExponent = 0.0;
 555    gl_compute_spot_exp_table( l );
 556    l->SpotCutoff = 180.0;
 557    l->CosCutoff = 0.0;          /* KW: -ve values not admitted */
 558    l->ConstantAttenuation = 1.0;
 559    l->LinearAttenuation = 0.0;
 560    l->QuadraticAttenuation = 0.0;
 561    l->Enabled = GL_FALSE;
 562 }
 563
 564
 565
 566 static void
 567 init_lightmodel( struct gl_lightmodel *lm )
 568 {
 569    ASSIGN_4V( lm->Ambient, 0.2, 0.2, 0.2, 1.0 );
 570    lm->LocalViewer = GL_FALSE;
 571    lm->TwoSide = GL_FALSE;
 572    lm->ColorControl = GL_SINGLE_COLOR;
 573 }
 574
 575
 576 static void
 577 init_material( struct gl_material *m )
 578 {
 579    ASSIGN_4V( m->Ambient,  0.2, 0.2, 0.2, 1.0 );
 580    ASSIGN_4V( m->Diffuse,  0.8, 0.8, 0.8, 1.0 );
 581    ASSIGN_4V( m->Specular, 0.0, 0.0, 0.0, 1.0 );
 582    ASSIGN_4V( m->Emission, 0.0, 0.0, 0.0, 1.0 );
 583    m->Shininess = 0.0;
 584    m->AmbientIndex = 0;
 585    m->DiffuseIndex = 1;
 586    m->SpecularIndex = 1;
 587 }
 588
 589
 590
 591 static void
 592 init_texture_unit( GLcontext *ctx, GLuint unit )
 593 {
 594    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 595
 596    texUnit->EnvMode = GL_MODULATE;
 597    ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
 598    texUnit->TexGenEnabled = 0;
 599    texUnit->GenModeS = GL_EYE_LINEAR;
 600    texUnit->GenModeT = GL_EYE_LINEAR;
 601    texUnit->GenModeR = GL_EYE_LINEAR;
 602    texUnit->GenModeQ = GL_EYE_LINEAR;
 603    /* Yes, these plane coefficients are correct! */
 604    ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 );
 605    ASSIGN_4V( texUnit->ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 );
 606    ASSIGN_4V( texUnit->ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 );
 607    ASSIGN_4V( texUnit->ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 );
 608    ASSIGN_4V( texUnit->EyePlaneS, 1.0, 0.0, 0.0, 0.0 );
 609    ASSIGN_4V( texUnit->EyePlaneT, 0.0, 1.0, 0.0, 0.0 );
 610    ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 );
 611    ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 );
 612
 613    texUnit->CurrentD[1] = ctx->Shared->DefaultD[1];
 614    texUnit->CurrentD[2] = ctx->Shared->DefaultD[2];
 615    texUnit->CurrentD[3] = ctx->Shared->DefaultD[3];
 616    texUnit->CurrentCubeMap = ctx->Shared->DefaultCubeMap;
 617 }
 618
 619
 620 static void
 621 init_fallback_arrays( GLcontext *ctx )
 622 {
 623    struct gl_client_array *cl;
 624    GLuint i;
 625
 626    cl = &ctx->Fallback.Normal;
 627    cl->Size = 3;
 628    cl->Type = GL_FLOAT;
 629    cl->Stride = 0;
 630    cl->StrideB = 0;
 631    cl->Ptr = (void *) ctx->Current.Normal;
 632    cl->Enabled = 1;
 633
 634    cl = &ctx->Fallback.Color;
 635    cl->Size = 4;
 636    cl->Type = GL_UNSIGNED_BYTE;
 637    cl->Stride = 0;
 638    cl->StrideB = 0;
 639    cl->Ptr = (void *) ctx->Current.ByteColor;
 640    cl->Enabled = 1;
 641
 642    cl = &ctx->Fallback.Index;
 643    cl->Size = 1;
 644    cl->Type = GL_UNSIGNED_INT;
 645    cl->Stride = 0;
 646    cl->StrideB = 0;
 647    cl->Ptr = (void *) &ctx->Current.Index;
 648    cl->Enabled = 1;
 649
 650    for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) {
 651       cl = &ctx->Fallback.TexCoord[i];
 652       cl->Size = 4;
 653       cl->Type = GL_FLOAT;
 654       cl->Stride = 0;
 655       cl->StrideB = 0;
 656       cl->Ptr = (void *) ctx->Current.Texcoord[i];
 657       cl->Enabled = 1;
 658    }
 659
 660    cl = &ctx->Fallback.EdgeFlag;
 661    cl->Size = 1;
 662    cl->Type = GL_UNSIGNED_BYTE;
 663    cl->Stride = 0;
 664    cl->StrideB = 0;
 665    cl->Ptr = (void *) &ctx->Current.EdgeFlag;
 666    cl->Enabled = 1;
 667 }
 668
 669
 670 /* Initialize a 1-D evaluator map */
 671 static void
 672 init_1d_map( struct gl_1d_map *map, int n, const float *initial )
 673 {
 674    map->Order = 1;
 675    map->u1 = 0.0;
 676    map->u2 = 1.0;
 677    map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat));
 678    if (map->Points) {
 679       GLint i;
 680       for (i=0;i<n;i++)
 681          map->Points[i] = initial[i];
 682    }
 683 }
 684
 685
 686 /* Initialize a 2-D evaluator map */
 687 static void
 688 init_2d_map( struct gl_2d_map *map, int n, const float *initial )
 689 {
 690    map->Uorder = 1;
 691    map->Vorder = 1;
 692    map->u1 = 0.0;
 693    map->u2 = 1.0;
 694    map->v1 = 0.0;
 695    map->v2 = 1.0;
 696    map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat));
 697    if (map->Points) {
 698       GLint i;
 699       for (i=0;i<n;i++)
 700          map->Points[i] = initial[i];
 701    }
 702 }
 703
 704
 705 /*
 706  * Initialize the attribute groups in a GLcontext.
 707  */
 708 static void
 709 init_attrib_groups( GLcontext *ctx )
 710 {
 711    GLuint i, j;
 712
 713    assert(ctx);
 714
 715    /* Constants, may be overriden by device drivers */
 716    ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
 717    ctx->Const.MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
 718    ctx->Const.MaxCubeTextureSize = ctx->Const.MaxTextureSize;
 719    ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
 720    ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
 721    ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
 722    ctx->Const.MinPointSize = MIN_POINT_SIZE;
 723    ctx->Const.MaxPointSize = MAX_POINT_SIZE;
 724    ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
 725    ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
 726    ctx->Const.PointSizeGranularity = POINT_SIZE_GRANULARITY;
 727    ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
 728    ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
 729    ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
 730    ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
 731    ctx->Const.LineWidthGranularity = LINE_WIDTH_GRANULARITY;
 732    ctx->Const.NumAuxBuffers = NUM_AUX_BUFFERS;
 733    ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
 734    ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
 735    ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
 736    ctx->Const.NumCompressedTextureFormats = 0;
 737
 738    /* Modelview matrix */
 739    gl_matrix_ctr( &ctx->ModelView );
 740    gl_matrix_alloc_inv( &ctx->ModelView );
 741
 742    ctx->ModelViewStackDepth = 0;
 743    for (i = 0; i < MAX_MODELVIEW_STACK_DEPTH - 1; i++) {
 744       gl_matrix_ctr( &ctx->ModelViewStack[i] );
 745       gl_matrix_alloc_inv( &ctx->ModelViewStack[i] );
 746    }
 747
 748    /* Projection matrix - need inv for user clipping in clip space*/
 749    gl_matrix_ctr( &ctx->ProjectionMatrix );
 750    gl_matrix_alloc_inv( &ctx->ProjectionMatrix );
 751
 752    gl_matrix_ctr( &ctx->ModelProjectMatrix );
 753    gl_matrix_ctr( &ctx->ModelProjectWinMatrix );
 754    ctx->ModelProjectWinMatrixUptodate = GL_FALSE;
 755
 756    ctx->ProjectionStackDepth = 0;
 757    ctx->NearFarStack[0][0] = 1.0; /* These values seem weird by make */
 758    ctx->NearFarStack[0][1] = 0.0; /* sense mathematically. */
 759
 760    for (i = 0; i < MAX_PROJECTION_STACK_DEPTH - 1; i++) {
 761       gl_matrix_ctr( &ctx->ProjectionStack[i] );
 762       gl_matrix_alloc_inv( &ctx->ProjectionStack[i] );
 763    }
 764
 765    /* Texture matrix */
 766    for (i=0; i<MAX_TEXTURE_UNITS; i++) {
 767       gl_matrix_ctr( &ctx->TextureMatrix[i] );
 768       ctx->TextureStackDepth[i] = 0;
 769       for (j = 0; j < MAX_TEXTURE_STACK_DEPTH - 1; j++) {
 770          ctx->TextureStack[i][j].inv = 0;
 771       }
 772    }
 773
 774    /* Color matrix */
 775    gl_matrix_ctr(&ctx->ColorMatrix);
 776    ctx->ColorStackDepth = 0;
 777    for (j = 0; j < MAX_COLOR_STACK_DEPTH - 1; j++) {
 778       gl_matrix_ctr(&ctx->ColorStack[j]);
 779    }
 780
 781    /* Accumulate buffer group */
 782    ASSIGN_4V( ctx->Accum.ClearColor, 0.0, 0.0, 0.0, 0.0 );
 783
 784    /* Color buffer group */
 785    ctx->Color.IndexMask = 0xffffffff;
 786    ctx->Color.ColorMask[0] = 0xff;
 787    ctx->Color.ColorMask[1] = 0xff;
 788    ctx->Color.ColorMask[2] = 0xff;
 789    ctx->Color.ColorMask[3] = 0xff;
 790    ctx->Color.SWmasking = GL_FALSE;
 791    ctx->Color.ClearIndex = 0;
 792    ASSIGN_4V( ctx->Color.ClearColor, 0.0, 0.0, 0.0, 0.0 );
 793    ctx->Color.DrawBuffer = GL_FRONT;
 794    ctx->Color.AlphaEnabled = GL_FALSE;
 795    ctx->Color.AlphaFunc = GL_ALWAYS;
 796    ctx->Color.AlphaRef = 0;
 797    ctx->Color.BlendEnabled = GL_FALSE;
 798    ctx->Color.BlendSrcRGB = GL_ONE;
 799    ctx->Color.BlendDstRGB = GL_ZERO;
 800    ctx->Color.BlendSrcA = GL_ONE;
 801    ctx->Color.BlendDstA = GL_ZERO;
 802    ctx->Color.BlendEquation = GL_FUNC_ADD_EXT;
 803    ctx->Color.BlendFunc = NULL;  /* this pointer set only when needed */
 804    ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );
 805    ctx->Color.IndexLogicOpEnabled = GL_FALSE;
 806    ctx->Color.ColorLogicOpEnabled = GL_FALSE;
 807    ctx->Color.SWLogicOpEnabled = GL_FALSE;
 808    ctx->Color.LogicOp = GL_COPY;
 809    ctx->Color.DitherFlag = GL_TRUE;
 810    ctx->Color.MultiDrawBuffer = GL_FALSE;
 811
 812    /* Current group */
 813    ASSIGN_4V( ctx->Current.ByteColor, 255, 255, 255, 255);
 814    ctx->Current.Index = 1;
 815    for (i=0; i<MAX_TEXTURE_UNITS; i++)
 816       ASSIGN_4V( ctx->Current.Texcoord[i], 0.0, 0.0, 0.0, 1.0 );
 817    ASSIGN_4V( ctx->Current.RasterPos, 0.0, 0.0, 0.0, 1.0 );
 818    ctx->Current.RasterDistance = 0.0;
 819    ASSIGN_4V( ctx->Current.RasterColor, 1.0, 1.0, 1.0, 1.0 );
 820    ctx->Current.RasterIndex = 1;
 821    for (i=0; i<MAX_TEXTURE_UNITS; i++)
 822       ASSIGN_4V( ctx->Current.RasterMultiTexCoord[i], 0.0, 0.0, 0.0, 1.0 );
 823    ctx->Current.RasterTexCoord = ctx->Current.RasterMultiTexCoord[0];
 824    ctx->Current.RasterPosValid = GL_TRUE;
 825    ctx->Current.EdgeFlag = GL_TRUE;
 826    ASSIGN_3V( ctx->Current.Normal, 0.0, 0.0, 1.0 );
 827    ctx->Current.Primitive = (GLenum) (GL_POLYGON + 1);
 828
 829    ctx->Current.Flag = (VERT_NORM|VERT_INDEX|VERT_RGBA|VERT_EDGE|
 830                         VERT_TEX0_1|VERT_TEX1_1|VERT_MATERIAL);
 831
 832    init_fallback_arrays( ctx );
 833
 834    /* Depth buffer group */
 835    ctx->Depth.Test = GL_FALSE;
 836    ctx->Depth.Clear = 1.0;
 837    ctx->Depth.Func = GL_LESS;
 838    ctx->Depth.Mask = GL_TRUE;
 839    ctx->Depth.OcclusionTest = GL_FALSE;
 840
 841    /* Evaluators group */
 842    ctx->Eval.Map1Color4 = GL_FALSE;
 843    ctx->Eval.Map1Index = GL_FALSE;
 844    ctx->Eval.Map1Normal = GL_FALSE;
 845    ctx->Eval.Map1TextureCoord1 = GL_FALSE;
 846    ctx->Eval.Map1TextureCoord2 = GL_FALSE;
 847    ctx->Eval.Map1TextureCoord3 = GL_FALSE;
 848    ctx->Eval.Map1TextureCoord4 = GL_FALSE;
 849    ctx->Eval.Map1Vertex3 = GL_FALSE;
 850    ctx->Eval.Map1Vertex4 = GL_FALSE;
 851    ctx->Eval.Map2Color4 = GL_FALSE;
 852    ctx->Eval.Map2Index = GL_FALSE;
 853    ctx->Eval.Map2Normal = GL_FALSE;
 854    ctx->Eval.Map2TextureCoord1 = GL_FALSE;
 855    ctx->Eval.Map2TextureCoord2 = GL_FALSE;
 856    ctx->Eval.Map2TextureCoord3 = GL_FALSE;
 857    ctx->Eval.Map2TextureCoord4 = GL_FALSE;
 858    ctx->Eval.Map2Vertex3 = GL_FALSE;
 859    ctx->Eval.Map2Vertex4 = GL_FALSE;
 860    ctx->Eval.AutoNormal = GL_FALSE;
 861    ctx->Eval.MapGrid1un = 1;
 862    ctx->Eval.MapGrid1u1 = 0.0;
 863    ctx->Eval.MapGrid1u2 = 1.0;
 864    ctx->Eval.MapGrid2un = 1;
 865    ctx->Eval.MapGrid2vn = 1;
 866    ctx->Eval.MapGrid2u1 = 0.0;
 867    ctx->Eval.MapGrid2u2 = 1.0;
 868    ctx->Eval.MapGrid2v1 = 0.0;
 869    ctx->Eval.MapGrid2v2 = 1.0;
 870
 871    /* Evaluator data */
 872    {
 873       static GLfloat vertex[4] = { 0.0, 0.0, 0.0, 1.0 };
 874       static GLfloat normal[3] = { 0.0, 0.0, 1.0 };
 875       static GLfloat index[1] = { 1.0 };
 876       static GLfloat color[4] = { 1.0, 1.0, 1.0, 1.0 };
 877       static GLfloat texcoord[4] = { 0.0, 0.0, 0.0, 1.0 };
 878
 879       init_1d_map( &ctx->EvalMap.Map1Vertex3, 3, vertex );
 880       init_1d_map( &ctx->EvalMap.Map1Vertex4, 4, vertex );
 881       init_1d_map( &ctx->EvalMap.Map1Index, 1, index );
 882       init_1d_map( &ctx->EvalMap.Map1Color4, 4, color );
 883       init_1d_map( &ctx->EvalMap.Map1Normal, 3, normal );
 884       init_1d_map( &ctx->EvalMap.Map1Texture1, 1, texcoord );
 885       init_1d_map( &ctx->EvalMap.Map1Texture2, 2, texcoord );
 886       init_1d_map( &ctx->EvalMap.Map1Texture3, 3, texcoord );
 887       init_1d_map( &ctx->EvalMap.Map1Texture4, 4, texcoord );
 888
 889       init_2d_map( &ctx->EvalMap.Map2Vertex3, 3, vertex );
 890       init_2d_map( &ctx->EvalMap.Map2Vertex4, 4, vertex );
 891       init_2d_map( &ctx->EvalMap.Map2Index, 1, index );
 892       init_2d_map( &ctx->EvalMap.Map2Color4, 4, color );
 893       init_2d_map( &ctx->EvalMap.Map2Normal, 3, normal );
 894       init_2d_map( &ctx->EvalMap.Map2Texture1, 1, texcoord );
 895       init_2d_map( &ctx->EvalMap.Map2Texture2, 2, texcoord );
 896       init_2d_map( &ctx->EvalMap.Map2Texture3, 3, texcoord );
 897       init_2d_map( &ctx->EvalMap.Map2Texture4, 4, texcoord );
 898    }
 899
 900    /* Fog group */
 901    ctx->Fog.Enabled = GL_FALSE;
 902    ctx->Fog.Mode = GL_EXP;
 903    ASSIGN_4V( ctx->Fog.Color, 0.0, 0.0, 0.0, 0.0 );
 904    ctx->Fog.Index = 0.0;
 905    ctx->Fog.Density = 1.0;
 906    ctx->Fog.Start = 0.0;
 907    ctx->Fog.End = 1.0;
 908
 909    /* Hint group */
 910    ctx->Hint.PerspectiveCorrection = GL_DONT_CARE;
 911    ctx->Hint.PointSmooth = GL_DONT_CARE;
 912    ctx->Hint.LineSmooth = GL_DONT_CARE;
 913    ctx->Hint.PolygonSmooth = GL_DONT_CARE;
 914    ctx->Hint.Fog = GL_DONT_CARE;
 915    ctx->Hint.AllowDrawWin = GL_TRUE;
 916    ctx->Hint.AllowDrawFrg = GL_TRUE;
 917    ctx->Hint.AllowDrawMem = GL_TRUE;
 918    ctx->Hint.StrictLighting = GL_TRUE;
 919    ctx->Hint.ClipVolumeClipping = GL_DONT_CARE;
 920    ctx->Hint.TextureCompression = GL_DONT_CARE;
 921
 922    /* Histogram group */
 923    ctx->Histogram.Width = 0;
 924    ctx->Histogram.Format = GL_RGBA;
 925    ctx->Histogram.Sink = GL_FALSE;
 926    ctx->Histogram.RedSize       = 0xffffffff;
 927    ctx->Histogram.GreenSize     = 0xffffffff;
 928    ctx->Histogram.BlueSize      = 0xffffffff;
 929    ctx->Histogram.AlphaSize     = 0xffffffff;
 930    ctx->Histogram.LuminanceSize = 0xffffffff;
 931    for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
 932       ctx->Histogram.Count[i][0] = 0;
 933       ctx->Histogram.Count[i][1] = 0;
 934       ctx->Histogram.Count[i][2] = 0;
 935       ctx->Histogram.Count[i][3] = 0;
 936    }
 937
 938    /* Min/Max group */
 939    ctx->MinMax.Format = GL_RGBA;
 940    ctx->MinMax.Sink = GL_FALSE;
 941    ctx->MinMax.Min[RCOMP] = 1000;    ctx->MinMax.Max[RCOMP] = -1000;
 942    ctx->MinMax.Min[GCOMP] = 1000;    ctx->MinMax.Max[GCOMP] = -1000;
 943    ctx->MinMax.Min[BCOMP] = 1000;    ctx->MinMax.Max[BCOMP] = -1000;
 944    ctx->MinMax.Min[ACOMP] = 1000;    ctx->MinMax.Max[ACOMP] = -1000;
 945
 946
 947
 948    /* Pipeline */
 949    gl_pipeline_init( ctx );
 950    gl_cva_init( ctx );
 951
 952    /* Extensions */
 953    gl_extensions_ctr( ctx );
 954
 955    ctx->AllowVertexCull = CLIP_CULLED_BIT;
 956
 957    /* Lighting group */
 958    for (i=0;i<MAX_LIGHTS;i++) {
 959       init_light( &ctx->Light.Light[i], i );
 960    }
 961    make_empty_list( &ctx->Light.EnabledList );
 962
 963    init_lightmodel( &ctx->Light.Model );
 964    init_material( &ctx->Light.Material[0] );
 965    init_material( &ctx->Light.Material[1] );
 966    ctx->Light.ShadeModel = GL_SMOOTH;
 967    ctx->Light.Enabled = GL_FALSE;
 968    ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK;
 969    ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE;
 970    ctx->Light.ColorMaterialBitmask
 971       = gl_material_bitmask( ctx,
 972                              GL_FRONT_AND_BACK,
 973                              GL_AMBIENT_AND_DIFFUSE, ~0, 0 );
 974
 975    ctx->Light.ColorMaterialEnabled = GL_FALSE;
 976
 977    /* Lighting miscellaneous */
 978    ctx->ShineTabList = MALLOC_STRUCT( gl_shine_tab );
 979    make_empty_list( ctx->ShineTabList );
 980    for (i = 0 ; i < 10 ; i++) {
 981       struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab );
 982       s->shininess = -1;
 983       s->refcount = 0;
 984       insert_at_tail( ctx->ShineTabList, s );
 985    }
 986    for (i = 0 ; i < 4 ; i++) {
 987       ctx->ShineTable[i] = ctx->ShineTabList->prev;
 988       ctx->ShineTable[i]->refcount++;
 989    }
 990
 991
 992    /* Line group */
 993    ctx->Line.SmoothFlag = GL_FALSE;
 994    ctx->Line.StippleFlag = GL_FALSE;
 995    ctx->Line.Width = 1.0;
 996    ctx->Line.StipplePattern = 0xffff;
 997    ctx->Line.StippleFactor = 1;
 998
 999    /* Display List group */
1000    ctx->List.ListBase = 0;
1001
1002    /* Pixel group */
1003    ctx->Pixel.RedBias = 0.0;
1004    ctx->Pixel.RedScale = 1.0;
1005    ctx->Pixel.GreenBias = 0.0;
1006    ctx->Pixel.GreenScale = 1.0;
1007    ctx->Pixel.BlueBias = 0.0;
1008    ctx->Pixel.BlueScale = 1.0;
1009    ctx->Pixel.AlphaBias = 0.0;
1010    ctx->Pixel.AlphaScale = 1.0;
1011    ctx->Pixel.ScaleOrBiasRGBA = GL_FALSE;
1012    ctx->Pixel.DepthBias = 0.0;
1013    ctx->Pixel.DepthScale = 1.0;
1014    ctx->Pixel.IndexOffset = 0;
1015    ctx->Pixel.IndexShift = 0;
1016    ctx->Pixel.ZoomX = 1.0;
1017    ctx->Pixel.ZoomY = 1.0;
1018    ctx->Pixel.MapColorFlag = GL_FALSE;
1019    ctx->Pixel.MapStencilFlag = GL_FALSE;
1020    ctx->Pixel.MapStoSsize = 1;
1021    ctx->Pixel.MapItoIsize = 1;
1022    ctx->Pixel.MapItoRsize = 1;
1023    ctx->Pixel.MapItoGsize = 1;
1024    ctx->Pixel.MapItoBsize = 1;
1025    ctx->Pixel.MapItoAsize = 1;
1026    ctx->Pixel.MapRtoRsize = 1;
1027    ctx->Pixel.MapGtoGsize = 1;
1028    ctx->Pixel.MapBtoBsize = 1;
1029    ctx->Pixel.MapAtoAsize = 1;
1030    ctx->Pixel.MapStoS[0] = 0;
1031    ctx->Pixel.MapItoI[0] = 0;
1032    ctx->Pixel.MapItoR[0] = 0.0;
1033    ctx->Pixel.MapItoG[0] = 0.0;
1034    ctx->Pixel.MapItoB[0] = 0.0;
1035    ctx->Pixel.MapItoA[0] = 0.0;
1036    ctx->Pixel.MapItoR8[0] = 0;
1037    ctx->Pixel.MapItoG8[0] = 0;
1038    ctx->Pixel.MapItoB8[0] = 0;
1039    ctx->Pixel.MapItoA8[0] = 0;
1040    ctx->Pixel.MapRtoR[0] = 0.0;
1041    ctx->Pixel.MapGtoG[0] = 0.0;
1042    ctx->Pixel.MapBtoB[0] = 0.0;
1043    ctx->Pixel.MapAtoA[0] = 0.0;
1044    ctx->Pixel.HistogramEnabled = GL_FALSE;
1045    ctx->Pixel.MinMaxEnabled = GL_FALSE;
1046    ctx->Pixel.PixelTextureEnabled = GL_FALSE;
1047    ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
1048    ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
1049    ASSIGN_4V(ctx->Pixel.PostColorMatrixScale, 1.0, 1.0, 1.0, 1.0);
1050    ASSIGN_4V(ctx->Pixel.PostColorMatrixBias, 0.0, 0.0, 0.0, 0.0);
1051    ASSIGN_4V(ctx->Pixel.ColorTableScale, 1.0, 1.0, 1.0, 1.0);
1052    ASSIGN_4V(ctx->Pixel.ColorTableBias, 0.0, 0.0, 0.0, 0.0);
1053    ctx->Pixel.ColorTableEnabled = GL_FALSE;
1054    ctx->Pixel.PostConvolutionColorTableEnabled = GL_FALSE;
1055    ctx->Pixel.PostColorMatrixColorTableEnabled = GL_FALSE;
1056    ctx->Pixel.Convolution1DEnabled = GL_FALSE;
1057    ctx->Pixel.Convolution2DEnabled = GL_FALSE;
1058    ctx->Pixel.Separable2DEnabled = GL_FALSE;
1059    for (i = 0; i < 3; i++) {
1060       ASSIGN_4V(ctx->Pixel.ConvolutionBorderColor[i], 0.0, 0.0, 0.0, 0.0);
1061       ctx->Pixel.ConvolutionBorderMode[i] = GL_REDUCE;
1062       ASSIGN_4V(ctx->Pixel.ConvolutionFilterScale[i], 1.0, 1.0, 1.0, 1.0);
1063       ASSIGN_4V(ctx->Pixel.ConvolutionFilterBias[i], 0.0, 0.0, 0.0, 0.0);
1064    }
1065    ASSIGN_4V(ctx->Pixel.PostConvolutionScale, 1.0, 1.0, 1.0, 1.0);
1066    ASSIGN_4V(ctx->Pixel.PostConvolutionBias, 0.0, 0.0, 0.0, 0.0);
1067
1068    /* Point group */
1069    ctx->Point.SmoothFlag = GL_FALSE;
1070    ctx->Point.UserSize = 1.0;
1071    ctx->Point.Size = 1.0;
1072    ctx->Point.Params[0] = 1.0;
1073    ctx->Point.Params[1] = 0.0;
1074    ctx->Point.Params[2] = 0.0;
1075    ctx->Point.Attenuated = GL_FALSE;
1076    ctx->Point.MinSize = 0.0;
1077    ctx->Point.MaxSize = (GLfloat) MAX_POINT_SIZE;
1078    ctx->Point.Threshold = 1.0;
1079
1080    /* Polygon group */
1081    ctx->Polygon.CullFlag = GL_FALSE;
1082    ctx->Polygon.CullFaceMode = GL_BACK;
1083    ctx->Polygon.FrontFace = GL_CCW;
1084    ctx->Polygon.FrontBit = 0;
1085    ctx->Polygon.FrontMode = GL_FILL;
1086    ctx->Polygon.BackMode = GL_FILL;
1087    ctx->Polygon.Unfilled = GL_FALSE;
1088    ctx->Polygon.SmoothFlag = GL_FALSE;
1089    ctx->Polygon.StippleFlag = GL_FALSE;
1090    ctx->Polygon.OffsetFactor = 0.0F;
1091    ctx->Polygon.OffsetUnits = 0.0F;
1092    ctx->Polygon.OffsetPoint = GL_FALSE;
1093    ctx->Polygon.OffsetLine = GL_FALSE;
1094    ctx->Polygon.OffsetFill = GL_FALSE;
1095
1096    /* Polygon Stipple group */
1097    MEMSET( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) );
1098
1099    /* Scissor group */
1100    ctx->Scissor.Enabled = GL_FALSE;
1101    ctx->Scissor.X = 0;
1102    ctx->Scissor.Y = 0;
1103    ctx->Scissor.Width = 0;
1104    ctx->Scissor.Height = 0;
1105
1106    /* Stencil group */
1107    ctx->Stencil.Enabled = GL_FALSE;
1108    ctx->Stencil.Function = GL_ALWAYS;
1109    ctx->Stencil.FailFunc = GL_KEEP;
1110    ctx->Stencil.ZPassFunc = GL_KEEP;
1111    ctx->Stencil.ZFailFunc = GL_KEEP;
1112    ctx->Stencil.Ref = 0;
1113    ctx->Stencil.ValueMask = STENCIL_MAX;
1114    ctx->Stencil.Clear = 0;
1115    ctx->Stencil.WriteMask = STENCIL_MAX;
1116
1117    /* Texture group */
1118    ctx->Texture.CurrentUnit = 0;      /* multitexture */
1119    ctx->Texture.CurrentTransformUnit = 0; /* multitexture */
1120    ctx->Texture.Enabled = 0;
1121    for (i=0; i<MAX_TEXTURE_UNITS; i++)
1122       init_texture_unit( ctx, i );
1123    _mesa_init_colortable(&ctx->Texture.Palette);
1124
1125    /* Transformation group */
1126    ctx->Transform.MatrixMode = GL_MODELVIEW;
1127    ctx->Transform.Normalize = GL_FALSE;
1128    ctx->Transform.RescaleNormals = GL_FALSE;
1129    for (i=0;i<MAX_CLIP_PLANES;i++) {
1130       ctx->Transform.ClipEnabled[i] = GL_FALSE;
1131       ASSIGN_4V( ctx->Transform.EyeUserPlane[i], 0.0, 0.0, 0.0, 0.0 );
1132    }
1133    ctx->Transform.AnyClip = GL_FALSE;
1134
1135    /* Viewport group */
1136    ctx->Viewport.X = 0;
1137    ctx->Viewport.Y = 0;
1138    ctx->Viewport.Width = 0;
1139    ctx->Viewport.Height = 0;
1140    ctx->Viewport.Near = 0.0;
1141    ctx->Viewport.Far = 1.0;
1142    gl_matrix_ctr(&ctx->Viewport.WindowMap);
1143
1144 #define Sz 10
1145 #define Tz 14
1146    ctx->Viewport.WindowMap.m[Sz] = 0.5 * ctx->Visual->DepthMaxF;
1147    ctx->Viewport.WindowMap.m[Tz] = 0.5 * ctx->Visual->DepthMaxF;
1148 #undef Sz
1149 #undef Tz
1150
1151    ctx->Viewport.WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
1152    ctx->Viewport.WindowMap.type = MATRIX_3D_NO_ROT;
1153
1154    /* Vertex arrays */
1155    ctx->Array.Vertex.Size = 4;
1156    ctx->Array.Vertex.Type = GL_FLOAT;
1157    ctx->Array.Vertex.Stride = 0;
1158    ctx->Array.Vertex.StrideB = 0;
1159    ctx->Array.Vertex.Ptr = NULL;
1160    ctx->Array.Vertex.Enabled = GL_FALSE;
1161    ctx->Array.Normal.Type = GL_FLOAT;
1162    ctx->Array.Normal.Stride = 0;
1163    ctx->Array.Normal.StrideB = 0;
1164    ctx->Array.Normal.Ptr = NULL;
1165    ctx->Array.Normal.Enabled = GL_FALSE;
1166    ctx->Array.Color.Size = 4;
1167    ctx->Array.Color.Type = GL_FLOAT;
1168    ctx->Array.Color.Stride = 0;
1169    ctx->Array.Color.StrideB = 0;
1170    ctx->Array.Color.Ptr = NULL;
1171    ctx->Array.Color.Enabled = GL_FALSE;
1172    ctx->Array.Index.Type = GL_FLOAT;
1173    ctx->Array.Index.Stride = 0;
1174    ctx->Array.Index.StrideB = 0;
1175    ctx->Array.Index.Ptr = NULL;
1176    ctx->Array.Index.Enabled = GL_FALSE;
1177    for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1178       ctx->Array.TexCoord[i].Size = 4;
1179       ctx->Array.TexCoord[i].Type = GL_FLOAT;
1180       ctx->Array.TexCoord[i].Stride = 0;
1181       ctx->Array.TexCoord[i].StrideB = 0;
1182       ctx->Array.TexCoord[i].Ptr = NULL;
1183       ctx->Array.TexCoord[i].Enabled = GL_FALSE;
1184    }
1185    ctx->Array.TexCoordInterleaveFactor = 1;
1186    ctx->Array.EdgeFlag.Stride = 0;
1187    ctx->Array.EdgeFlag.StrideB = 0;
1188    ctx->Array.EdgeFlag.Ptr = NULL;
1189    ctx->Array.EdgeFlag.Enabled = GL_FALSE;
1190    ctx->Array.ActiveTexture = 0;   /* GL_ARB_multitexture */
1191
1192    /* Pixel transfer */
1193    ctx->Pack.Alignment = 4;
1194    ctx->Pack.RowLength = 0;
1195    ctx->Pack.ImageHeight = 0;
1196    ctx->Pack.SkipPixels = 0;
1197    ctx->Pack.SkipRows = 0;
1198    ctx->Pack.SkipImages = 0;
1199    ctx->Pack.SwapBytes = GL_FALSE;
1200    ctx->Pack.LsbFirst = GL_FALSE;
1201    ctx->Unpack.Alignment = 4;
1202    ctx->Unpack.RowLength = 0;
1203    ctx->Unpack.ImageHeight = 0;
1204    ctx->Unpack.SkipPixels = 0;
1205    ctx->Unpack.SkipRows = 0;
1206    ctx->Unpack.SkipImages = 0;
1207    ctx->Unpack.SwapBytes = GL_FALSE;
1208    ctx->Unpack.LsbFirst = GL_FALSE;
1209
1210    /* Feedback */
1211    ctx->Feedback.Type = GL_2D;   /* TODO: verify */
1212    ctx->Feedback.Buffer = NULL;
1213    ctx->Feedback.BufferSize = 0;
1214    ctx->Feedback.Count = 0;
1215
1216    /* Selection/picking */
1217    ctx->Select.Buffer = NULL;
1218    ctx->Select.BufferSize = 0;
1219    ctx->Select.BufferCount = 0;
1220    ctx->Select.Hits = 0;
1221    ctx->Select.NameStackDepth = 0;
1222
1223    /* Optimized Accum buffer */
1224    ctx->IntegerAccumMode = GL_TRUE;
1225    ctx->IntegerAccumScaler = 0.0;
1226
1227    /* Renderer and client attribute stacks */
1228    ctx->AttribStackDepth = 0;
1229    ctx->ClientAttribStackDepth = 0;
1230
1231    /* Display list */
1232    ctx->CallDepth = 0;
1233    ctx->ExecuteFlag = GL_TRUE;
1234    ctx->CompileFlag = GL_FALSE;
1235    ctx->CurrentListPtr = NULL;
1236    ctx->CurrentBlock = NULL;
1237    ctx->CurrentListNum = 0;
1238    ctx->CurrentPos = 0;
1239
1240    /* Color tables */
1241    _mesa_init_colortable(&ctx->ColorTable);
1242    _mesa_init_colortable(&ctx->ProxyColorTable);
1243    _mesa_init_colortable(&ctx->PostConvolutionColorTable);
1244    _mesa_init_colortable(&ctx->ProxyPostConvolutionColorTable);
1245    _mesa_init_colortable(&ctx->PostColorMatrixColorTable);
1246    _mesa_init_colortable(&ctx->ProxyPostColorMatrixColorTable);
1247
1248    /* Miscellaneous */
1249    ctx->NewState = NEW_ALL;
1250    ctx->RenderMode = GL_RENDER;
1251    ctx->StippleCounter = 0;
1252    ctx->NeedNormals = GL_FALSE;
1253    ctx->DoViewportMapping = GL_TRUE;
1254
1255    ctx->NeedEyeCoords = GL_FALSE;
1256    ctx->NeedEyeNormals = GL_FALSE;
1257    ctx->vb_proj_matrix = &ctx->ModelProjectMatrix;
1258
1259    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1260
1261    ctx->CatchSignals = GL_TRUE;
1262    ctx->OcclusionResult = GL_FALSE;
1263    ctx->OcclusionResultSaved = GL_FALSE;
1264
1265    /* For debug/development only */
1266    ctx->NoRaster = getenv("MESA_NO_RASTER") ? GL_TRUE : GL_FALSE;
1267    ctx->FirstTimeCurrent = GL_TRUE;
1268
1269    /* Dither disable */
1270    ctx->NoDither = getenv("MESA_NO_DITHER") ? GL_TRUE : GL_FALSE;
1271    if (ctx->NoDither) {
1272       if (getenv("MESA_DEBUG")) {
1273          fprintf(stderr, "MESA_NO_DITHER set - dithering disabled\n");
1274       }
1275       ctx->Color.DitherFlag = GL_FALSE;
1276    }
1277 }
1278
1279
1280
1281
1282 /*
1283  * Allocate the proxy textures.  If we run out of memory part way through
1284  * the allocations clean up and return GL_FALSE.
1285  * Return:  GL_TRUE=success, GL_FALSE=failure
1286  */
1287 static GLboolean
1288 alloc_proxy_textures( GLcontext *ctx )
1289 {
1290    GLboolean out_of_memory;
1291    GLint i;
1292
1293    ctx->Texture.Proxy1D = gl_alloc_texture_object(NULL, 0, 1);
1294    if (!ctx->Texture.Proxy1D) {
1295       return GL_FALSE;
1296    }
1297
1298    ctx->Texture.Proxy2D = gl_alloc_texture_object(NULL, 0, 2);
1299    if (!ctx->Texture.Proxy2D) {
1300       gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
1301       return GL_FALSE;
1302    }
1303
1304    ctx->Texture.Proxy3D = gl_alloc_texture_object(NULL, 0, 3);
1305    if (!ctx->Texture.Proxy3D) {
1306       gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
1307       gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
1308       return GL_FALSE;
1309    }
1310
1311    out_of_memory = GL_FALSE;
1312    for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1313       ctx->Texture.Proxy1D->Image[i] = _mesa_alloc_texture_image();
1314       ctx->Texture.Proxy2D->Image[i] = _mesa_alloc_texture_image();
1315       ctx->Texture.Proxy3D->Image[i] = _mesa_alloc_texture_image();
1316       if (!ctx->Texture.Proxy1D->Image[i]
1317           || !ctx->Texture.Proxy2D->Image[i]
1318           || !ctx->Texture.Proxy3D->Image[i]) {
1319          out_of_memory = GL_TRUE;
1320       }
1321    }
1322    if (out_of_memory) {
1323       for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1324          if (ctx->Texture.Proxy1D->Image[i]) {
1325             _mesa_free_texture_image(ctx->Texture.Proxy1D->Image[i]);
1326          }
1327          if (ctx->Texture.Proxy2D->Image[i]) {
1328             _mesa_free_texture_image(ctx->Texture.Proxy2D->Image[i]);
1329          }
1330          if (ctx->Texture.Proxy3D->Image[i]) {
1331             _mesa_free_texture_image(ctx->Texture.Proxy3D->Image[i]);
1332          }
1333       }
1334       gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
1335       gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
1336       gl_free_texture_object(NULL, ctx->Texture.Proxy3D);
1337       return GL_FALSE;
1338    }
1339    else {
1340       return GL_TRUE;
1341    }
1342 }
1343
1344
1345
1346 /*
1347  * Initialize a GLcontext struct.
1348  */
1349 GLboolean
1350 _mesa_initialize_context( GLcontext *ctx,
1351                           GLvisual *visual,
1352                           GLcontext *share_list,
1353                           void *driver_ctx,
1354                           GLboolean direct )
1355 {
1356    GLuint dispatchSize;
1357
1358    (void) direct;  /* not used */
1359
1360    /* misc one-time initializations */
1361    one_time_init();
1362
1363    ctx->DriverCtx = driver_ctx;
1364    ctx->Visual = visual;
1365    ctx->DrawBuffer = NULL;
1366    ctx->ReadBuffer = NULL;
1367
1368    ctx->VB = gl_vb_create_for_immediate( ctx );
1369    if (!ctx->VB) {
1370       FREE( ctx );
1371       return GL_FALSE;
1372    }
1373    ctx->input = ctx->VB->IM;
1374
1375    ctx->PB = gl_alloc_pb();
1376    if (!ctx->PB) {
1377       FREE( ctx->VB );
1378       FREE( ctx );
1379       return GL_FALSE;
1380    }
1381
1382    if (share_list) {
1383       /* share the group of display lists of another context */
1384       ctx->Shared = share_list->Shared;
1385    }
1386    else {
1387       /* allocate new group of display lists */
1388       ctx->Shared = alloc_shared_state();
1389       if (!ctx->Shared) {
1390          FREE(ctx->VB);
1391          FREE(ctx->PB);
1392          FREE(ctx);
1393          return GL_FALSE;
1394       }
1395    }
1396    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1397    ctx->Shared->RefCount++;
1398    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1399
1400    init_attrib_groups( ctx );
1401
1402    gl_reset_vb( ctx->VB );
1403    gl_reset_input( ctx );
1404
1405    if (visual->DBflag) {
1406       ctx->Color.DrawBuffer = GL_BACK;
1407       ctx->Color.DriverDrawBuffer = GL_BACK_LEFT;
1408       ctx->Color.DrawDestMask = BACK_LEFT_BIT;
1409       ctx->Pixel.ReadBuffer = GL_BACK;
1410       ctx->Pixel.DriverReadBuffer = GL_BACK_LEFT;
1411    }
1412    else {
1413       ctx->Color.DrawBuffer = GL_FRONT;
1414       ctx->Color.DriverDrawBuffer = GL_FRONT_LEFT;
1415       ctx->Color.DrawDestMask = FRONT_LEFT_BIT;
1416       ctx->Pixel.ReadBuffer = GL_FRONT;
1417       ctx->Pixel.DriverReadBuffer = GL_FRONT_LEFT;
1418    }
1419
1420    if (!alloc_proxy_textures(ctx)) {
1421       free_shared_state(ctx, ctx->Shared);
1422       FREE(ctx->VB);
1423       FREE(ctx->PB);
1424       FREE(ctx);
1425       return GL_FALSE;
1426    }
1427
1428    /* register the most recent extension functions with libGL */
1429    _glapi_add_entrypoint("glTbufferMask3DFX", 553);
1430    _glapi_add_entrypoint("glCompressedTexImage3DARB", 554);
1431    _glapi_add_entrypoint("glCompressedTexImage2DARB", 555);
1432    _glapi_add_entrypoint("glCompressedTexImage1DARB", 556);
1433    _glapi_add_entrypoint("glCompressedTexSubImage3DARB", 557);
1434    _glapi_add_entrypoint("glCompressedTexSubImage2DARB", 558);
1435    _glapi_add_entrypoint("glCompressedTexSubImage1DARB", 559);
1436    _glapi_add_entrypoint("glGetCompressedTexImageARB", 560);
1437
1438    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1439     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
1440     * Mesa we do this to accomodate different versions of libGL and various
1441     * DRI drivers.
1442     */
1443    dispatchSize = MAX2(_glapi_get_dispatch_table_size(),
1444                        sizeof(struct _glapi_table) / sizeof(void *));
1445
1446    /* setup API dispatch tables */
1447    ctx->Exec = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
1448    ctx->Save = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
1449    if (!ctx->Exec || !ctx->Save) {
1450       free_shared_state(ctx, ctx->Shared);
1451       FREE(ctx->VB);
1452       FREE(ctx->PB);
1453       if (ctx->Exec)
1454          FREE(ctx->Exec);
1455       FREE(ctx);
1456    }
1457    _mesa_init_exec_table(ctx->Exec, dispatchSize);
1458    _mesa_init_dlist_table(ctx->Save, dispatchSize);
1459    ctx->CurrentDispatch = ctx->Exec;
1460
1461    return GL_TRUE;
1462 }
1463
1464
1465
1466 /*
1467  * Allocate and initialize a GLcontext structure.
1468  * Input:  visual - a GLvisual pointer
1469  *         sharelist - another context to share display lists with or NULL
1470  *         driver_ctx - pointer to device driver's context state struct
1471  * Return:  pointer to a new gl_context struct or NULL if error.
1472  */
1473 GLcontext *
1474 gl_create_context( GLvisual *visual,
1475                    GLcontext *share_list,
1476                    void *driver_ctx,
1477                    GLboolean direct )
1478 {
1479    GLcontext *ctx = (GLcontext *) CALLOC( sizeof(GLcontext) );
1480    if (!ctx) {
1481       return NULL;
1482    }
1483
1484    if (_mesa_initialize_context(ctx, visual, share_list, driver_ctx, direct)) {
1485       return ctx;
1486    }
1487    else {
1488       FREE(ctx);
1489       return NULL;
1490    }
1491 }
1492
1493
1494
1495 /*
1496  * Free the data associated with the given context.
1497  * But don't free() the GLcontext struct itself!
1498  */
1499 void
1500 gl_free_context_data( GLcontext *ctx )
1501 {
1502    struct gl_shine_tab *s, *tmps;
1503    GLuint i, j;
1504
1505    /* if we're destroying the current context, unbind it first */
1506    if (ctx == gl_get_current_context()) {
1507       gl_make_current(NULL, NULL);
1508    }
1509
1510    gl_matrix_dtr( &ctx->ModelView );
1511    for (i = 0; i < MAX_MODELVIEW_STACK_DEPTH - 1; i++) {
1512       gl_matrix_dtr( &ctx->ModelViewStack[i] );
1513    }
1514    gl_matrix_dtr( &ctx->ProjectionMatrix );
1515    for (i = 0; i < MAX_PROJECTION_STACK_DEPTH - 1; i++) {
1516       gl_matrix_dtr( &ctx->ProjectionStack[i] );
1517    }
1518    for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1519       gl_matrix_dtr( &ctx->TextureMatrix[i] );
1520       for (j = 0; j < MAX_TEXTURE_STACK_DEPTH - 1; j++) {
1521          gl_matrix_dtr( &ctx->TextureStack[i][j] );
1522       }
1523    }
1524
1525    FREE( ctx->PB );
1526
1527    if (ctx->input != ctx->VB->IM)
1528       gl_immediate_free( ctx->input );
1529
1530    gl_vb_free( ctx->VB );
1531
1532    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1533    ctx->Shared->RefCount--;
1534    assert(ctx->Shared->RefCount >= 0);
1535    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1536    if (ctx->Shared->RefCount == 0) {
1537       /* free shared state */
1538       free_shared_state( ctx, ctx->Shared );
1539    }
1540
1541    foreach_s( s, tmps, ctx->ShineTabList ) {
1542       FREE( s );
1543    }
1544    FREE( ctx->ShineTabList );
1545
1546    /* Free proxy texture objects */
1547    gl_free_texture_object( NULL, ctx->Texture.Proxy1D );
1548    gl_free_texture_object( NULL, ctx->Texture.Proxy2D );
1549    gl_free_texture_object( NULL, ctx->Texture.Proxy3D );
1550
1551    /* Free evaluator data */
1552    if (ctx->EvalMap.Map1Vertex3.Points)
1553       FREE( ctx->EvalMap.Map1Vertex3.Points );
1554    if (ctx->EvalMap.Map1Vertex4.Points)
1555       FREE( ctx->EvalMap.Map1Vertex4.Points );
1556    if (ctx->EvalMap.Map1Index.Points)
1557       FREE( ctx->EvalMap.Map1Index.Points );
1558    if (ctx->EvalMap.Map1Color4.Points)
1559       FREE( ctx->EvalMap.Map1Color4.Points );
1560    if (ctx->EvalMap.Map1Normal.Points)
1561       FREE( ctx->EvalMap.Map1Normal.Points );
1562    if (ctx->EvalMap.Map1Texture1.Points)
1563       FREE( ctx->EvalMap.Map1Texture1.Points );
1564    if (ctx->EvalMap.Map1Texture2.Points)
1565       FREE( ctx->EvalMap.Map1Texture2.Points );
1566    if (ctx->EvalMap.Map1Texture3.Points)
1567       FREE( ctx->EvalMap.Map1Texture3.Points );
1568    if (ctx->EvalMap.Map1Texture4.Points)
1569       FREE( ctx->EvalMap.Map1Texture4.Points );
1570
1571    if (ctx->EvalMap.Map2Vertex3.Points)
1572       FREE( ctx->EvalMap.Map2Vertex3.Points );
1573    if (ctx->EvalMap.Map2Vertex4.Points)
1574       FREE( ctx->EvalMap.Map2Vertex4.Points );
1575    if (ctx->EvalMap.Map2Index.Points)
1576       FREE( ctx->EvalMap.Map2Index.Points );
1577    if (ctx->EvalMap.Map2Color4.Points)
1578       FREE( ctx->EvalMap.Map2Color4.Points );
1579    if (ctx->EvalMap.Map2Normal.Points)
1580       FREE( ctx->EvalMap.Map2Normal.Points );
1581    if (ctx->EvalMap.Map2Texture1.Points)
1582       FREE( ctx->EvalMap.Map2Texture1.Points );
1583    if (ctx->EvalMap.Map2Texture2.Points)
1584       FREE( ctx->EvalMap.Map2Texture2.Points );
1585    if (ctx->EvalMap.Map2Texture3.Points)
1586       FREE( ctx->EvalMap.Map2Texture3.Points );
1587    if (ctx->EvalMap.Map2Texture4.Points)
1588       FREE( ctx->EvalMap.Map2Texture4.Points );
1589
1590    _mesa_free_colortable_data( &ctx->ColorTable );
1591    _mesa_free_colortable_data( &ctx->PostConvolutionColorTable );
1592    _mesa_free_colortable_data( &ctx->PostColorMatrixColorTable );
1593    _mesa_free_colortable_data( &ctx->Texture.Palette );
1594
1595    /* Free cache of immediate buffers. */
1596    while (ctx->nr_im_queued-- > 0) {
1597       struct immediate * next = ctx->freed_im_queue->next;
1598       FREE( ctx->freed_im_queue );
1599       ctx->freed_im_queue = next;
1600    }
1601    gl_extensions_dtr(ctx);
1602
1603    FREE(ctx->Exec);
1604    FREE(ctx->Save);
1605 }
1606
1607
1608
1609 /*
1610  * Destroy a GLcontext structure.
1611  */
1612 void
1613 gl_destroy_context( GLcontext *ctx )
1614 {
1615    if (ctx) {
1616       gl_free_context_data(ctx);
1617       FREE( (void *) ctx );
1618    }
1619 }
1620
1621
1622
1623 /*
1624  * Called by the driver after both the context and driver are fully
1625  * initialized.  Currently just reads the config file.
1626  */
1627 void
1628 gl_context_initialize( GLcontext *ctx )
1629 {
1630    gl_read_config_file( ctx );
1631 }
1632
1633
1634
1635 /*
1636  * Copy attribute groups from one context to another.
1637  * Input:  src - source context
1638  *         dst - destination context
1639  *         mask - bitwise OR of GL_*_BIT flags
1640  */
1641 void
1642 gl_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1643 {
1644    if (mask & GL_ACCUM_BUFFER_BIT) {
1645       MEMCPY( &dst->Accum, &src->Accum, sizeof(struct gl_accum_attrib) );
1646    }
1647    if (mask & GL_COLOR_BUFFER_BIT) {
1648       MEMCPY( &dst->Color, &src->Color, sizeof(struct gl_colorbuffer_attrib) );
1649    }
1650    if (mask & GL_CURRENT_BIT) {
1651       MEMCPY( &dst->Current, &src->Current, sizeof(struct gl_current_attrib) );
1652    }
1653    if (mask & GL_DEPTH_BUFFER_BIT) {
1654       MEMCPY( &dst->Depth, &src->Depth, sizeof(struct gl_depthbuffer_attrib) );
1655    }
1656    if (mask & GL_ENABLE_BIT) {
1657       /* no op */
1658    }
1659    if (mask & GL_EVAL_BIT) {
1660       MEMCPY( &dst->Eval, &src->Eval, sizeof(struct gl_eval_attrib) );
1661    }
1662    if (mask & GL_FOG_BIT) {
1663       MEMCPY( &dst->Fog, &src->Fog, sizeof(struct gl_fog_attrib) );
1664    }
1665    if (mask & GL_HINT_BIT) {
1666       MEMCPY( &dst->Hint, &src->Hint, sizeof(struct gl_hint_attrib) );
1667    }
1668    if (mask & GL_LIGHTING_BIT) {
1669       MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light_attrib) );
1670       /*       gl_reinit_light_attrib( &dst->Light ); */
1671    }
1672    if (mask & GL_LINE_BIT) {
1673       MEMCPY( &dst->Line, &src->Line, sizeof(struct gl_line_attrib) );
1674    }
1675    if (mask & GL_LIST_BIT) {
1676       MEMCPY( &dst->List, &src->List, sizeof(struct gl_list_attrib) );
1677    }
1678    if (mask & GL_PIXEL_MODE_BIT) {
1679       MEMCPY( &dst->Pixel, &src->Pixel, sizeof(struct gl_pixel_attrib) );
1680    }
1681    if (mask & GL_POINT_BIT) {
1682       MEMCPY( &dst->Point, &src->Point, sizeof(struct gl_point_attrib) );
1683    }
1684    if (mask & GL_POLYGON_BIT) {
1685       MEMCPY( &dst->Polygon, &src->Polygon, sizeof(struct gl_polygon_attrib) );
1686    }
1687    if (mask & GL_POLYGON_STIPPLE_BIT) {
1688       /* Use loop instead of MEMCPY due to problem with Portland Group's
1689        * C compiler.  Reported by John Stone.
1690        */
1691       int i;
1692       for (i=0;i<32;i++) {
1693          dst->PolygonStipple[i] = src->PolygonStipple[i];
1694       }
1695    }
1696    if (mask & GL_SCISSOR_BIT) {
1697       MEMCPY( &dst->Scissor, &src->Scissor, sizeof(struct gl_scissor_attrib) );
1698    }
1699    if (mask & GL_STENCIL_BUFFER_BIT) {
1700       MEMCPY( &dst->Stencil, &src->Stencil, sizeof(struct gl_stencil_attrib) );
1701    }
1702    if (mask & GL_TEXTURE_BIT) {
1703       MEMCPY( &dst->Texture, &src->Texture, sizeof(struct gl_texture_attrib) );
1704    }
1705    if (mask & GL_TRANSFORM_BIT) {
1706       MEMCPY( &dst->Transform, &src->Transform, sizeof(struct gl_transform_attrib) );
1707    }
1708    if (mask & GL_VIEWPORT_BIT) {
1709       MEMCPY( &dst->Viewport, &src->Viewport, sizeof(struct gl_viewport_attrib) );
1710    }
1711 }
1712
1713
1714 /*
1715  * Set the current context, binding the given frame buffer to the context.
1716  */
1717 void gl_make_current( GLcontext *newCtx, GLframebuffer *buffer )
1718 {
1719    gl_make_current2( newCtx, buffer, buffer );
1720 }
1721
1722
1723 /*
1724  * Bind the given context to the given draw-buffer and read-buffer
1725  * and make it the current context for this thread.
1726  */
1727 void gl_make_current2( GLcontext *newCtx, GLframebuffer *drawBuffer,
1728                        GLframebuffer *readBuffer )
1729 {
1730 #if 0
1731    GLcontext *oldCtx = gl_get_context();
1732
1733    /* Flush the old context
1734     */
1735    if (oldCtx) {
1736       ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(oldCtx, "gl_make_current");
1737
1738       /* unbind frame buffers from context */
1739       if (oldCtx->DrawBuffer) {
1740          oldCtx->DrawBuffer = NULL;
1741       }
1742       if (oldCtx->ReadBuffer) {
1743          oldCtx->ReadBuffer = NULL;
1744       }
1745    }
1746 #endif
1747
1748    /* We call this function periodically (just here for now) in
1749     * order to detect when multithreading has begun.
1750     */
1751    _glapi_check_multithread();
1752
1753    _glapi_set_context((void *) newCtx);
1754    ASSERT(gl_get_current_context() == newCtx);
1755    if (newCtx) {
1756       SET_IMMEDIATE(newCtx, newCtx->input);
1757       _glapi_set_dispatch(newCtx->CurrentDispatch);
1758    }
1759    else {
1760       _glapi_set_dispatch(NULL);  /* none current */
1761    }
1762
1763    if (MESA_VERBOSE) fprintf(stderr, "gl_make_current()\n");
1764
1765    if (newCtx && drawBuffer && readBuffer) {
1766       /* TODO: check if newCtx and buffer's visual match??? */
1767       newCtx->DrawBuffer = drawBuffer;
1768       newCtx->ReadBuffer = readBuffer;
1769       newCtx->NewState = NEW_ALL;   /* just to be safe */
1770       gl_update_state( newCtx );
1771    }
1772
1773    /* We can use this to help debug user's problems.  Tell the to set
1774     * the MESA_INFO env variable before running their app.  Then the
1775     * first time each context is made current we'll print some useful
1776     * information.
1777     */
1778    if (newCtx && newCtx->FirstTimeCurrent) {
1779       if (getenv("MESA_INFO")) {
1780          fprintf(stderr, "Mesa GL_VERSION = %s\n", (char *) _mesa_GetString(GL_VERSION));
1781          fprintf(stderr, "Mesa GL_RENDERER = %s\n", (char *) _mesa_GetString(GL_RENDERER));
1782          fprintf(stderr, "Mesa GL_VENDOR = %s\n", (char *) _mesa_GetString(GL_VENDOR));
1783          fprintf(stderr, "Mesa GL_EXTENSIONS = %s\n", (char *) _mesa_GetString(GL_EXTENSIONS));
1784 #if defined(THREADS)
1785          fprintf(stderr, "Mesa thread-safe: YES\n");
1786 #else
1787          fprintf(stderr, "Mesa thread-safe: NO\n");
1788 #endif
1789 #if defined(USE_X86_ASM)
1790          fprintf(stderr, "Mesa x86-optimized: YES\n");
1791 #else
1792          fprintf(stderr, "Mesa x86-optimized: NO\n");
1793 #endif
1794       }
1795       newCtx->FirstTimeCurrent = GL_FALSE;
1796    }
1797 }
1798
1799
1800
1801 /*
1802  * Return current context handle for the calling thread.
1803  * This isn't the fastest way to get the current context.
1804  * If you need speed, see the GET_CURRENT_CONTEXT() macro in context.h
1805  */
1806 GLcontext *gl_get_current_context( void )
1807 {
1808    return (GLcontext *) _glapi_get_context();
1809 }
1810
1811
1812
1813 /*
1814  * This should be called by device drivers just before they do a
1815  * swapbuffers.  Any pending rendering commands will be executed.
1816  */
1817 void
1818 _mesa_swapbuffers(GLcontext *ctx)
1819 {
1820    FLUSH_VB( ctx, "swap buffers" );
1821 }
1822
1823
1824
1825 /*
1826  * Return pointer to this context's current API dispatch table.
1827  * It'll either be the immediate-mode execute dispatcher or the
1828  * display list compile dispatcher.
1829  */
1830 struct _glapi_table *
1831 _mesa_get_dispatch(GLcontext *ctx)
1832 {
1833    return ctx->CurrentDispatch;
1834 }
1835
1836
1837
1838 /**********************************************************************/
1839 /*****                Miscellaneous functions                     *****/
1840 /**********************************************************************/
1841
1842
1843 /*
1844  * This function is called when the Mesa user has stumbled into a code
1845  * path which may not be implemented fully or correctly.
1846  */
1847 void gl_problem( const GLcontext *ctx, const char *s )
1848 {
1849    fprintf( stderr, "Mesa implementation error: %s\n", s );
1850    fprintf( stderr, "Report to Mesa bug database at www.mesa3d.org\n" );
1851    (void) ctx;
1852 }
1853
1854
1855
1856 /*
1857  * This is called to inform the user that he or she has tried to do
1858  * something illogical or if there's likely a bug in their program
1859  * (like enabled depth testing without a depth buffer).
1860  */
1861 void gl_warning( const GLcontext *ctx, const char *s )
1862 {
1863    GLboolean debug;
1864 #ifdef DEBUG
1865    debug = GL_TRUE;
1866 #else
1867    if (getenv("MESA_DEBUG")) {
1868       debug = GL_TRUE;
1869    }
1870    else {
1871       debug = GL_FALSE;
1872    }
1873 #endif
1874    if (debug) {
1875       fprintf( stderr, "Mesa warning: %s\n", s );
1876    }
1877    (void) ctx;
1878 }
1879
1880
1881
1882 /*
1883  * Compile an error into current display list.
1884  */
1885 void gl_compile_error( GLcontext *ctx, GLenum error, const char *s )
1886 {
1887    if (ctx->CompileFlag)
1888       gl_save_error( ctx, error, s );
1889
1890    if (ctx->ExecuteFlag)
1891       gl_error( ctx, error, s );
1892 }
1893
1894
1895
1896 /*
1897  * This is Mesa's error handler.  Normally, all that's done is the updating
1898  * of the current error value.  If Mesa is compiled with -DDEBUG or if the
1899  * environment variable "MESA_DEBUG" is defined then a real error message
1900  * is printed to stderr.
1901  * Input:  error - the error value
1902  *         s - a diagnostic string
1903  */
1904 void gl_error( GLcontext *ctx, GLenum error, const char *s )
1905 {
1906    GLboolean debug;
1907
1908 #ifdef DEBUG
1909    debug = GL_TRUE;
1910 #else
1911    if (getenv("MESA_DEBUG")) {
1912       debug = GL_TRUE;
1913    }
1914    else {
1915       debug = GL_FALSE;
1916    }
1917 #endif
1918
1919    if (debug) {
1920       char errstr[1000];
1921
1922       switch (error) {
1923          case GL_NO_ERROR:
1924             strcpy( errstr, "GL_NO_ERROR" );
1925             break;
1926          case GL_INVALID_VALUE:
1927             strcpy( errstr, "GL_INVALID_VALUE" );
1928             break;
1929          case GL_INVALID_ENUM:
1930             strcpy( errstr, "GL_INVALID_ENUM" );
1931             break;
1932          case GL_INVALID_OPERATION:
1933             strcpy( errstr, "GL_INVALID_OPERATION" );
1934             break;
1935          case GL_STACK_OVERFLOW:
1936             strcpy( errstr, "GL_STACK_OVERFLOW" );
1937             break;
1938          case GL_STACK_UNDERFLOW:
1939             strcpy( errstr, "GL_STACK_UNDERFLOW" );
1940             break;
1941          case GL_OUT_OF_MEMORY:
1942             strcpy( errstr, "GL_OUT_OF_MEMORY" );
1943             break;
1944          default:
1945             strcpy( errstr, "unknown" );
1946             break;
1947       }
1948       fprintf( stderr, "Mesa user error: %s in %s\n", errstr, s );
1949    }
1950
1951    if (ctx->ErrorValue==GL_NO_ERROR) {
1952       ctx->ErrorValue = error;
1953    }
1954
1955    /* Call device driver's error handler, if any.  This is used on the Mac. */
1956    if (ctx->Driver.Error) {
1957       (*ctx->Driver.Error)( ctx );
1958    }
1959 }
1960
1961
1962
1963 void
1964 _mesa_Finish( void )
1965 {
1966    GET_CURRENT_CONTEXT(ctx);
1967    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glFinish");
1968    if (ctx->Driver.Finish) {
1969       (*ctx->Driver.Finish)( ctx );
1970    }
1971 }
1972
1973
1974
1975 void
1976 _mesa_Flush( void )
1977 {
1978    GET_CURRENT_CONTEXT(ctx);
1979    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glFlush");
1980    if (ctx->Driver.Flush) {
1981       (*ctx->Driver.Flush)( ctx );
1982    }
1983 }