src/mesa/main/context.c

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