src/mesa/main/context.c

   1 /* $Id: context.c,v 1.25 1999/12/02 20:33:06 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.3
   6  *
   7  * Copyright (C) 1999  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 /*
  29  * If multi-threading is enabled (-DTHREADS) then each thread has it's
  30  * own rendering context.  A thread obtains the pointer to its GLcontext
  31  * with the gl_get_thread_context() function.  Otherwise, the global
  32  * pointer, CC, points to the current context used by all threads in
  33  * the address space.
  34  */
  35
  36
  37 #ifdef PC_HEADER
  38 #include "all.h"
  39 #else
  40 #include "glheader.h"
  41 #include "accum.h"
  42 #include "alphabuf.h"
  43 #include "clip.h"
  44 #include "context.h"
  45 #include "cva.h"
  46 #include "depth.h"
  47 #include "dispatch.h"
  48 #include "dlist.h"
  49 #include "eval.h"
  50 #include "enums.h"
  51 #include "extensions.h"
  52 #include "fog.h"
  53 #include "get.h"
  54 #include "glapi.h"
  55 #include "hash.h"
  56 #include "light.h"
  57 #include "lines.h"
  58 #include "dlist.h"
  59 #include "macros.h"
  60 #include "matrix.h"
  61 #include "mem.h"
  62 #include "mmath.h"
  63 #include "pb.h"
  64 #include "pipeline.h"
  65 #include "points.h"
  66 #include "quads.h"
  67 #include "shade.h"
  68 #include "simple_list.h"
  69 #include "stencil.h"
  70 #include "stages.h"
  71 #include "triangle.h"
  72 #include "translate.h"
  73 #include "teximage.h"
  74 #include "texobj.h"
  75 #include "texstate.h"
  76 #include "texture.h"
  77 #include "types.h"
  78 #include "varray.h"
  79 #include "vb.h"
  80 #include "vbcull.h"
  81 #include "vbfill.h"
  82 #include "vbrender.h"
  83 #include "vbxform.h"
  84 #include "vertices.h"
  85 #include "xform.h"
  86 #endif
  87
  88
  89
  90 /**********************************************************************/
  91 /*****                  Context and Thread management             *****/
  92 /**********************************************************************/
  93
  94
  95 #ifdef THREADS
  96
  97 #include "mthreads.h"
  98 static MesaTSD mesa_ctx_tsd;
  99 static void mesa_ctx_thread_init() {
 100   MesaInitTSD(&mesa_ctx_tsd);
 101 }
 102
 103 #else
 104
 105 /* One Current Context pointer for all threads in the address space */
 106 GLcontext *_mesa_current_context = NULL;
 107 struct immediate *CURRENT_INPUT = NULL;
 108
 109 #endif /*THREADS*/
 110
 111
 112
 113
 114 /**********************************************************************/
 115 /*****                   Profiling functions                      *****/
 116 /**********************************************************************/
 117
 118 #ifdef PROFILE
 119
 120 #include <sys/times.h>
 121 #include <sys/param.h>
 122
 123
 124 /*
 125  * Return system time in seconds.
 126  * NOTE:  this implementation may not be very portable!
 127  */
 128 GLdouble gl_time( void )
 129 {
 130    static GLdouble prev_time = 0.0;
 131    static GLdouble time;
 132    struct tms tm;
 133    clock_t clk;
 134
 135    clk = times(&tm);
 136
 137 #ifdef CLK_TCK
 138    time = (double)clk / (double)CLK_TCK;
 139 #else
 140    time = (double)clk / (double)HZ;
 141 #endif
 142
 143    if (time>prev_time) {
 144       prev_time = time;
 145       return time;
 146    }
 147    else {
 148       return prev_time;
 149    }
 150 }
 151
 152 /*
 153  * Reset the timing/profiling counters
 154  */
 155 static void init_timings( GLcontext *ctx )
 156 {
 157    ctx->BeginEndCount = 0;
 158    ctx->BeginEndTime = 0.0;
 159    ctx->VertexCount = 0;
 160    ctx->VertexTime = 0.0;
 161    ctx->PointCount = 0;
 162    ctx->PointTime = 0.0;
 163    ctx->LineCount = 0;
 164    ctx->LineTime = 0.0;
 165    ctx->PolygonCount = 0;
 166    ctx->PolygonTime = 0.0;
 167    ctx->ClearCount = 0;
 168    ctx->ClearTime = 0.0;
 169    ctx->SwapCount = 0;
 170    ctx->SwapTime = 0.0;
 171 }
 172
 173
 174 /*
 175  * Print the accumulated timing/profiling data.
 176  */
 177 static void print_timings( GLcontext *ctx )
 178 {
 179    GLdouble beginendrate;
 180    GLdouble vertexrate;
 181    GLdouble pointrate;
 182    GLdouble linerate;
 183    GLdouble polygonrate;
 184    GLdouble overhead;
 185    GLdouble clearrate;
 186    GLdouble swaprate;
 187    GLdouble avgvertices;
 188
 189    if (ctx->BeginEndTime>0.0) {
 190       beginendrate = ctx->BeginEndCount / ctx->BeginEndTime;
 191    }
 192    else {
 193       beginendrate = 0.0;
 194    }
 195    if (ctx->VertexTime>0.0) {
 196       vertexrate = ctx->VertexCount / ctx->VertexTime;
 197    }
 198    else {
 199       vertexrate = 0.0;
 200    }
 201    if (ctx->PointTime>0.0) {
 202       pointrate = ctx->PointCount / ctx->PointTime;
 203    }
 204    else {
 205       pointrate = 0.0;
 206    }
 207    if (ctx->LineTime>0.0) {
 208       linerate = ctx->LineCount / ctx->LineTime;
 209    }
 210    else {
 211       linerate = 0.0;
 212    }
 213    if (ctx->PolygonTime>0.0) {
 214       polygonrate = ctx->PolygonCount / ctx->PolygonTime;
 215    }
 216    else {
 217       polygonrate = 0.0;
 218    }
 219    if (ctx->ClearTime>0.0) {
 220       clearrate = ctx->ClearCount / ctx->ClearTime;
 221    }
 222    else {
 223       clearrate = 0.0;
 224    }
 225    if (ctx->SwapTime>0.0) {
 226       swaprate = ctx->SwapCount / ctx->SwapTime;
 227    }
 228    else {
 229       swaprate = 0.0;
 230    }
 231
 232    if (ctx->BeginEndCount>0) {
 233       avgvertices = (GLdouble) ctx->VertexCount / (GLdouble) ctx->BeginEndCount;
 234    }
 235    else {
 236       avgvertices = 0.0;
 237    }
 238
 239    overhead = ctx->BeginEndTime - ctx->VertexTime - ctx->PointTime
 240               - ctx->LineTime - ctx->PolygonTime;
 241
 242
 243    printf("                          Count   Time (s)    Rate (/s) \n");
 244    printf("--------------------------------------------------------\n");
 245    printf("glBegin/glEnd           %7d  %8.3f   %10.3f\n",
 246           ctx->BeginEndCount, ctx->BeginEndTime, beginendrate);
 247    printf("  vertexes transformed  %7d  %8.3f   %10.3f\n",
 248           ctx->VertexCount, ctx->VertexTime, vertexrate );
 249    printf("  points rasterized     %7d  %8.3f   %10.3f\n",
 250           ctx->PointCount, ctx->PointTime, pointrate );
 251    printf("  lines rasterized      %7d  %8.3f   %10.3f\n",
 252           ctx->LineCount, ctx->LineTime, linerate );
 253    printf("  polygons rasterized   %7d  %8.3f   %10.3f\n",
 254           ctx->PolygonCount, ctx->PolygonTime, polygonrate );
 255    printf("  overhead                       %8.3f\n", overhead );
 256    printf("glClear                 %7d  %8.3f   %10.3f\n",
 257           ctx->ClearCount, ctx->ClearTime, clearrate );
 258    printf("SwapBuffers             %7d  %8.3f   %10.3f\n",
 259           ctx->SwapCount, ctx->SwapTime, swaprate );
 260    printf("\n");
 261
 262    printf("Average number of vertices per begin/end: %8.3f\n", avgvertices );
 263 }
 264 #endif
 265
 266
 267
 268
 269
 270 /**********************************************************************/
 271 /*****       Context allocation, initialization, destroying       *****/
 272 /**********************************************************************/
 273
 274
 275 /*
 276  * This function just calls all the various one-time-init functions in Mesa.
 277  */
 278 static void one_time_init( void )
 279 {
 280    static GLboolean alreadyCalled = GL_FALSE;
 281    if (!alreadyCalled) {
 282       gl_init_clip();
 283       gl_init_eval();
 284       gl_init_fog();
 285       gl_init_math();
 286       gl_init_lists();
 287       gl_init_shade();
 288       gl_init_texture();
 289       gl_init_transformation();
 290       gl_init_translate();
 291       gl_init_vbrender();
 292       gl_init_vbxform();
 293       gl_init_vertices();
 294       alreadyCalled = GL_TRUE;
 295    }
 296 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
 297    fprintf(stderr, "Mesa DEBUG build %s %s\n", __DATE__, __TIME__);
 298 #endif
 299 }
 300
 301
 302 /*
 303  * Allocate and initialize a shared context state structure.
 304  */
 305 static struct gl_shared_state *alloc_shared_state( void )
 306 {
 307    GLuint d;
 308    struct gl_shared_state *ss;
 309    GLboolean outOfMemory;
 310
 311    ss = CALLOC_STRUCT(gl_shared_state);
 312    if (!ss)
 313       return NULL;
 314
 315    ss->DisplayList = NewHashTable();
 316
 317    ss->TexObjects = NewHashTable();
 318
 319    /* Default Texture objects */
 320    outOfMemory = GL_FALSE;
 321    for (d = 1 ; d <= 3 ; d++) {
 322       ss->DefaultD[d] = gl_alloc_texture_object(ss, 0, d);
 323       if (!ss->DefaultD[d]) {
 324          outOfMemory = GL_TRUE;
 325          break;
 326       }
 327       ss->DefaultD[d]->RefCount++; /* don't free if not in use */
 328    }
 329
 330    if (!ss->DisplayList || !ss->TexObjects || outOfMemory) {
 331       /* Ran out of memory at some point.  Free everything and return NULL */
 332       if (ss->DisplayList)
 333          DeleteHashTable(ss->DisplayList);
 334       if (ss->TexObjects)
 335          DeleteHashTable(ss->TexObjects);
 336       if (ss->DefaultD[1])
 337          gl_free_texture_object(ss, ss->DefaultD[1]);
 338       if (ss->DefaultD[2])
 339          gl_free_texture_object(ss, ss->DefaultD[2]);
 340       if (ss->DefaultD[3])
 341          gl_free_texture_object(ss, ss->DefaultD[3]);
 342       FREE(ss);
 343       return NULL;
 344    }
 345    else {
 346       return ss;
 347    }
 348 }
 349
 350
 351 /*
 352  * Deallocate a shared state context and all children structures.
 353  */
 354 static void free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
 355 {
 356    /* Free display lists */
 357    while (1) {
 358       GLuint list = HashFirstEntry(ss->DisplayList);
 359       if (list) {
 360          gl_destroy_list(ctx, list);
 361       }
 362       else {
 363          break;
 364       }
 365    }
 366    DeleteHashTable(ss->DisplayList);
 367
 368    /* Free texture objects */
 369    while (ss->TexObjectList)
 370    {
 371       if (ctx->Driver.DeleteTexture)
 372          (*ctx->Driver.DeleteTexture)( ctx, ss->TexObjectList );
 373       /* this function removes from linked list too! */
 374       gl_free_texture_object(ss, ss->TexObjectList);
 375    }
 376    DeleteHashTable(ss->TexObjects);
 377
 378    FREE(ss);
 379 }
 380
 381
 382
 383
 384
 385
 386 /*
 387  * Initialize the nth light.  Note that the defaults for light 0 are
 388  * different than the other lights.
 389  */
 390 static void init_light( struct gl_light *l, GLuint n )
 391 {
 392    make_empty_list( l );
 393
 394    ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 );
 395    if (n==0) {
 396       ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 );
 397       ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 );
 398    }
 399    else {
 400       ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 );
 401       ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 );
 402    }
 403    ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 );
 404    ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 );
 405    l->SpotExponent = 0.0;
 406    gl_compute_spot_exp_table( l );
 407    l->SpotCutoff = 180.0;
 408    l->CosCutoff = 0.0;          /* KW: -ve values not admitted */
 409    l->ConstantAttenuation = 1.0;
 410    l->LinearAttenuation = 0.0;
 411    l->QuadraticAttenuation = 0.0;
 412    l->Enabled = GL_FALSE;
 413 }
 414
 415
 416
 417 static void init_lightmodel( struct gl_lightmodel *lm )
 418 {
 419    ASSIGN_4V( lm->Ambient, 0.2, 0.2, 0.2, 1.0 );
 420    lm->LocalViewer = GL_FALSE;
 421    lm->TwoSide = GL_FALSE;
 422    lm->ColorControl = GL_SINGLE_COLOR;
 423 }
 424
 425
 426 static void init_material( struct gl_material *m )
 427 {
 428    ASSIGN_4V( m->Ambient,  0.2, 0.2, 0.2, 1.0 );
 429    ASSIGN_4V( m->Diffuse,  0.8, 0.8, 0.8, 1.0 );
 430    ASSIGN_4V( m->Specular, 0.0, 0.0, 0.0, 1.0 );
 431    ASSIGN_4V( m->Emission, 0.0, 0.0, 0.0, 1.0 );
 432    m->Shininess = 0.0;
 433    m->AmbientIndex = 0;
 434    m->DiffuseIndex = 1;
 435    m->SpecularIndex = 1;
 436 }
 437
 438
 439
 440 static void init_texture_unit( GLcontext *ctx, GLuint unit )
 441 {
 442    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 443
 444    texUnit->EnvMode = GL_MODULATE;
 445    ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
 446    texUnit->TexGenEnabled = 0;
 447    texUnit->GenModeS = GL_EYE_LINEAR;
 448    texUnit->GenModeT = GL_EYE_LINEAR;
 449    texUnit->GenModeR = GL_EYE_LINEAR;
 450    texUnit->GenModeQ = GL_EYE_LINEAR;
 451    /* Yes, these plane coefficients are correct! */
 452    ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 );
 453    ASSIGN_4V( texUnit->ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 );
 454    ASSIGN_4V( texUnit->ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 );
 455    ASSIGN_4V( texUnit->ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 );
 456    ASSIGN_4V( texUnit->EyePlaneS, 1.0, 0.0, 0.0, 0.0 );
 457    ASSIGN_4V( texUnit->EyePlaneT, 0.0, 1.0, 0.0, 0.0 );
 458    ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 );
 459    ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 );
 460
 461    texUnit->CurrentD[1] = ctx->Shared->DefaultD[1];
 462    texUnit->CurrentD[2] = ctx->Shared->DefaultD[2];
 463    texUnit->CurrentD[3] = ctx->Shared->DefaultD[3];
 464 }
 465
 466
 467 static void init_fallback_arrays( GLcontext *ctx )
 468 {
 469    struct gl_client_array *cl;
 470    GLuint i;
 471
 472    cl = &ctx->Fallback.Normal;
 473    cl->Size = 3;
 474    cl->Type = GL_FLOAT;
 475    cl->Stride = 0;
 476    cl->StrideB = 0;
 477    cl->Ptr = (void *) ctx->Current.Normal;
 478    cl->Enabled = 1;
 479
 480    cl = &ctx->Fallback.Color;
 481    cl->Size = 4;
 482    cl->Type = GL_UNSIGNED_BYTE;
 483    cl->Stride = 0;
 484    cl->StrideB = 0;
 485    cl->Ptr = (void *) ctx->Current.ByteColor;
 486    cl->Enabled = 1;
 487
 488    cl = &ctx->Fallback.Index;
 489    cl->Size = 1;
 490    cl->Type = GL_UNSIGNED_INT;
 491    cl->Stride = 0;
 492    cl->StrideB = 0;
 493    cl->Ptr = (void *) &ctx->Current.Index;
 494    cl->Enabled = 1;
 495
 496    for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) {
 497       cl = &ctx->Fallback.TexCoord[i];
 498       cl->Size = 4;
 499       cl->Type = GL_FLOAT;
 500       cl->Stride = 0;
 501       cl->StrideB = 0;
 502       cl->Ptr = (void *) ctx->Current.Texcoord[i];
 503       cl->Enabled = 1;
 504    }
 505
 506    cl = &ctx->Fallback.EdgeFlag;
 507    cl->Size = 1;
 508    cl->Type = GL_UNSIGNED_BYTE;
 509    cl->Stride = 0;
 510    cl->StrideB = 0;
 511    cl->Ptr = (void *) &ctx->Current.EdgeFlag;
 512    cl->Enabled = 1;
 513 }
 514
 515 /* Initialize a 1-D evaluator map */
 516 static void init_1d_map( struct gl_1d_map *map, int n, const float *initial )
 517 {
 518    map->Order = 1;
 519    map->u1 = 0.0;
 520    map->u2 = 1.0;
 521    map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat));
 522    if (map->Points) {
 523       GLint i;
 524       for (i=0;i<n;i++)
 525          map->Points[i] = initial[i];
 526    }
 527 }
 528
 529
 530 /* Initialize a 2-D evaluator map */
 531 static void init_2d_map( struct gl_2d_map *map, int n, const float *initial )
 532 {
 533    map->Uorder = 1;
 534    map->Vorder = 1;
 535    map->u1 = 0.0;
 536    map->u2 = 1.0;
 537    map->v1 = 0.0;
 538    map->v2 = 1.0;
 539    map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat));
 540    if (map->Points) {
 541       GLint i;
 542       for (i=0;i<n;i++)
 543          map->Points[i] = initial[i];
 544    }
 545 }
 546
 547
 548 static void init_color_table( struct gl_color_table *p )
 549 {
 550    p->Table[0] = 255;
 551    p->Table[1] = 255;
 552    p->Table[2] = 255;
 553    p->Table[3] = 255;
 554    p->Size = 1;
 555    p->IntFormat = GL_RGBA;
 556    p->Format = GL_RGBA;
 557 }
 558
 559
 560 /*
 561  * Initialize a gl_context structure to default values.
 562  */
 563 static void initialize_context( GLcontext *ctx )
 564 {
 565    GLuint i, j;
 566
 567    if (ctx) {
 568       /* Constants, may be overriden by device driver */
 569       ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
 570       ctx->Const.MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
 571       ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
 572       ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
 573
 574       /* Modelview matrix */
 575       gl_matrix_ctr( &ctx->ModelView );
 576       gl_matrix_alloc_inv( &ctx->ModelView );
 577
 578       ctx->ModelViewStackDepth = 0;
 579       for (i = 0 ; i < MAX_MODELVIEW_STACK_DEPTH ; i++) {
 580          gl_matrix_ctr( &ctx->ModelViewStack[i] );
 581          gl_matrix_alloc_inv( &ctx->ModelViewStack[i] );
 582       }
 583
 584       /* Projection matrix - need inv for user clipping in clip space*/
 585       gl_matrix_ctr( &ctx->ProjectionMatrix );
 586       gl_matrix_alloc_inv( &ctx->ProjectionMatrix );
 587
 588       gl_matrix_ctr( &ctx->ModelProjectMatrix );
 589       gl_matrix_ctr( &ctx->ModelProjectWinMatrix );
 590       ctx->ModelProjectWinMatrixUptodate = GL_FALSE;
 591
 592       ctx->ProjectionStackDepth = 0;
 593       ctx->NearFarStack[0][0] = 1.0; /* These values seem weird by make */
 594       ctx->NearFarStack[0][1] = 0.0; /* sense mathematically. */
 595
 596       for (i = 0 ; i < MAX_PROJECTION_STACK_DEPTH ; i++) {
 597          gl_matrix_ctr( &ctx->ProjectionStack[i] );
 598          gl_matrix_alloc_inv( &ctx->ProjectionStack[i] );
 599       }
 600
 601       /* Texture matrix */
 602       for (i=0; i<MAX_TEXTURE_UNITS; i++) {
 603          gl_matrix_ctr( &ctx->TextureMatrix[i] );
 604          ctx->TextureStackDepth[i] = 0;
 605          for (j = 0 ; j < MAX_TEXTURE_STACK_DEPTH ; j++) {
 606             ctx->TextureStack[i][j].inv = 0;
 607          }
 608       }
 609
 610       /* Accumulate buffer group */
 611       ASSIGN_4V( ctx->Accum.ClearColor, 0.0, 0.0, 0.0, 0.0 );
 612
 613       /* Color buffer group */
 614       ctx->Color.IndexMask = 0xffffffff;
 615       ctx->Color.ColorMask[0] = 0xff;
 616       ctx->Color.ColorMask[1] = 0xff;
 617       ctx->Color.ColorMask[2] = 0xff;
 618       ctx->Color.ColorMask[3] = 0xff;
 619       ctx->Color.SWmasking = GL_FALSE;
 620       ctx->Color.ClearIndex = 0;
 621       ASSIGN_4V( ctx->Color.ClearColor, 0.0, 0.0, 0.0, 0.0 );
 622       ctx->Color.DrawBuffer = GL_FRONT;
 623       ctx->Color.AlphaEnabled = GL_FALSE;
 624       ctx->Color.AlphaFunc = GL_ALWAYS;
 625       ctx->Color.AlphaRef = 0;
 626       ctx->Color.BlendEnabled = GL_FALSE;
 627       ctx->Color.BlendSrcRGB = GL_ONE;
 628       ctx->Color.BlendDstRGB = GL_ZERO;
 629       ctx->Color.BlendSrcA = GL_ONE;
 630       ctx->Color.BlendDstA = GL_ZERO;
 631       ctx->Color.BlendEquation = GL_FUNC_ADD_EXT;
 632       ctx->Color.BlendFunc = NULL;  /* this pointer set only when needed */
 633       ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );
 634       ctx->Color.IndexLogicOpEnabled = GL_FALSE;
 635       ctx->Color.ColorLogicOpEnabled = GL_FALSE;
 636       ctx->Color.SWLogicOpEnabled = GL_FALSE;
 637       ctx->Color.LogicOp = GL_COPY;
 638       ctx->Color.DitherFlag = GL_TRUE;
 639       ctx->Color.MultiDrawBuffer = GL_FALSE;
 640
 641       /* Current group */
 642       ASSIGN_4V( ctx->Current.ByteColor, 255, 255, 255, 255);
 643       ctx->Current.Index = 1;
 644       for (i=0; i<MAX_TEXTURE_UNITS; i++)
 645          ASSIGN_4V( ctx->Current.Texcoord[i], 0.0, 0.0, 0.0, 1.0 );
 646       ASSIGN_4V( ctx->Current.RasterPos, 0.0, 0.0, 0.0, 1.0 );
 647       ctx->Current.RasterDistance = 0.0;
 648       ASSIGN_4V( ctx->Current.RasterColor, 1.0, 1.0, 1.0, 1.0 );
 649       ctx->Current.RasterIndex = 1;
 650       for (i=0; i<MAX_TEXTURE_UNITS; i++)
 651          ASSIGN_4V( ctx->Current.RasterMultiTexCoord[i], 0.0, 0.0, 0.0, 1.0 );
 652       ctx->Current.RasterTexCoord = ctx->Current.RasterMultiTexCoord[0];
 653       ctx->Current.RasterPosValid = GL_TRUE;
 654       ctx->Current.EdgeFlag = GL_TRUE;
 655       ASSIGN_3V( ctx->Current.Normal, 0.0, 0.0, 1.0 );
 656       ctx->Current.Primitive = (GLenum) (GL_POLYGON + 1);
 657
 658       ctx->Current.Flag = (VERT_NORM|VERT_INDEX|VERT_RGBA|VERT_EDGE|
 659                            VERT_TEX0_1|VERT_TEX1_1|VERT_MATERIAL);
 660
 661       init_fallback_arrays( ctx );
 662
 663       /* Depth buffer group */
 664       ctx->Depth.Test = GL_FALSE;
 665       ctx->Depth.Clear = 1.0;
 666       ctx->Depth.Func = GL_LESS;
 667       ctx->Depth.Mask = GL_TRUE;
 668
 669       /* Evaluators group */
 670       ctx->Eval.Map1Color4 = GL_FALSE;
 671       ctx->Eval.Map1Index = GL_FALSE;
 672       ctx->Eval.Map1Normal = GL_FALSE;
 673       ctx->Eval.Map1TextureCoord1 = GL_FALSE;
 674       ctx->Eval.Map1TextureCoord2 = GL_FALSE;
 675       ctx->Eval.Map1TextureCoord3 = GL_FALSE;
 676       ctx->Eval.Map1TextureCoord4 = GL_FALSE;
 677       ctx->Eval.Map1Vertex3 = GL_FALSE;
 678       ctx->Eval.Map1Vertex4 = GL_FALSE;
 679       ctx->Eval.Map2Color4 = GL_FALSE;
 680       ctx->Eval.Map2Index = GL_FALSE;
 681       ctx->Eval.Map2Normal = GL_FALSE;
 682       ctx->Eval.Map2TextureCoord1 = GL_FALSE;
 683       ctx->Eval.Map2TextureCoord2 = GL_FALSE;
 684       ctx->Eval.Map2TextureCoord3 = GL_FALSE;
 685       ctx->Eval.Map2TextureCoord4 = GL_FALSE;
 686       ctx->Eval.Map2Vertex3 = GL_FALSE;
 687       ctx->Eval.Map2Vertex4 = GL_FALSE;
 688       ctx->Eval.AutoNormal = GL_FALSE;
 689       ctx->Eval.MapGrid1un = 1;
 690       ctx->Eval.MapGrid1u1 = 0.0;
 691       ctx->Eval.MapGrid1u2 = 1.0;
 692       ctx->Eval.MapGrid2un = 1;
 693       ctx->Eval.MapGrid2vn = 1;
 694       ctx->Eval.MapGrid2u1 = 0.0;
 695       ctx->Eval.MapGrid2u2 = 1.0;
 696       ctx->Eval.MapGrid2v1 = 0.0;
 697       ctx->Eval.MapGrid2v2 = 1.0;
 698
 699       /* Evaluator data */
 700       {
 701          static GLfloat vertex[4] = { 0.0, 0.0, 0.0, 1.0 };
 702          static GLfloat normal[3] = { 0.0, 0.0, 1.0 };
 703          static GLfloat index[1] = { 1.0 };
 704          static GLfloat color[4] = { 1.0, 1.0, 1.0, 1.0 };
 705          static GLfloat texcoord[4] = { 0.0, 0.0, 0.0, 1.0 };
 706
 707          init_1d_map( &ctx->EvalMap.Map1Vertex3, 3, vertex );
 708          init_1d_map( &ctx->EvalMap.Map1Vertex4, 4, vertex );
 709          init_1d_map( &ctx->EvalMap.Map1Index, 1, index );
 710          init_1d_map( &ctx->EvalMap.Map1Color4, 4, color );
 711          init_1d_map( &ctx->EvalMap.Map1Normal, 3, normal );
 712          init_1d_map( &ctx->EvalMap.Map1Texture1, 1, texcoord );
 713          init_1d_map( &ctx->EvalMap.Map1Texture2, 2, texcoord );
 714          init_1d_map( &ctx->EvalMap.Map1Texture3, 3, texcoord );
 715          init_1d_map( &ctx->EvalMap.Map1Texture4, 4, texcoord );
 716
 717          init_2d_map( &ctx->EvalMap.Map2Vertex3, 3, vertex );
 718          init_2d_map( &ctx->EvalMap.Map2Vertex4, 4, vertex );
 719          init_2d_map( &ctx->EvalMap.Map2Index, 1, index );
 720          init_2d_map( &ctx->EvalMap.Map2Color4, 4, color );
 721          init_2d_map( &ctx->EvalMap.Map2Normal, 3, normal );
 722          init_2d_map( &ctx->EvalMap.Map2Texture1, 1, texcoord );
 723          init_2d_map( &ctx->EvalMap.Map2Texture2, 2, texcoord );
 724          init_2d_map( &ctx->EvalMap.Map2Texture3, 3, texcoord );
 725          init_2d_map( &ctx->EvalMap.Map2Texture4, 4, texcoord );
 726       }
 727
 728       /* Fog group */
 729       ctx->Fog.Enabled = GL_FALSE;
 730       ctx->Fog.Mode = GL_EXP;
 731       ASSIGN_4V( ctx->Fog.Color, 0.0, 0.0, 0.0, 0.0 );
 732       ctx->Fog.Index = 0.0;
 733       ctx->Fog.Density = 1.0;
 734       ctx->Fog.Start = 0.0;
 735       ctx->Fog.End = 1.0;
 736
 737       /* Hint group */
 738       ctx->Hint.PerspectiveCorrection = GL_DONT_CARE;
 739       ctx->Hint.PointSmooth = GL_DONT_CARE;
 740       ctx->Hint.LineSmooth = GL_DONT_CARE;
 741       ctx->Hint.PolygonSmooth = GL_DONT_CARE;
 742       ctx->Hint.Fog = GL_DONT_CARE;
 743
 744       ctx->Hint.AllowDrawWin = GL_TRUE;
 745       ctx->Hint.AllowDrawSpn = GL_TRUE;
 746       ctx->Hint.AllowDrawMem = GL_TRUE;
 747       ctx->Hint.StrictLighting = GL_TRUE;
 748
 749       /* Pipeline */
 750       gl_pipeline_init( ctx );
 751       gl_cva_init( ctx );
 752
 753       /* Extensions */
 754       gl_extensions_ctr( ctx );
 755
 756       ctx->AllowVertexCull = CLIP_CULLED_BIT;
 757
 758       /* Lighting group */
 759       for (i=0;i<MAX_LIGHTS;i++) {
 760          init_light( &ctx->Light.Light[i], i );
 761       }
 762       make_empty_list( &ctx->Light.EnabledList );
 763
 764       init_lightmodel( &ctx->Light.Model );
 765       init_material( &ctx->Light.Material[0] );
 766       init_material( &ctx->Light.Material[1] );
 767       ctx->Light.ShadeModel = GL_SMOOTH;
 768       ctx->Light.Enabled = GL_FALSE;
 769       ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK;
 770       ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE;
 771       ctx->Light.ColorMaterialBitmask
 772          = gl_material_bitmask( ctx,
 773                                 GL_FRONT_AND_BACK,
 774                                 GL_AMBIENT_AND_DIFFUSE, ~0, 0 );
 775
 776       ctx->Light.ColorMaterialEnabled = GL_FALSE;
 777
 778       /* Line group */
 779       ctx->Line.SmoothFlag = GL_FALSE;
 780       ctx->Line.StippleFlag = GL_FALSE;
 781       ctx->Line.Width = 1.0;
 782       ctx->Line.StipplePattern = 0xffff;
 783       ctx->Line.StippleFactor = 1;
 784
 785       /* Display List group */
 786       ctx->List.ListBase = 0;
 787
 788       /* Pixel group */
 789       ctx->Pixel.RedBias = 0.0;
 790       ctx->Pixel.RedScale = 1.0;
 791       ctx->Pixel.GreenBias = 0.0;
 792       ctx->Pixel.GreenScale = 1.0;
 793       ctx->Pixel.BlueBias = 0.0;
 794       ctx->Pixel.BlueScale = 1.0;
 795       ctx->Pixel.AlphaBias = 0.0;
 796       ctx->Pixel.AlphaScale = 1.0;
 797       ctx->Pixel.ScaleOrBiasRGBA = GL_FALSE;
 798       ctx->Pixel.DepthBias = 0.0;
 799       ctx->Pixel.DepthScale = 1.0;
 800       ctx->Pixel.IndexOffset = 0;
 801       ctx->Pixel.IndexShift = 0;
 802       ctx->Pixel.ZoomX = 1.0;
 803       ctx->Pixel.ZoomY = 1.0;
 804       ctx->Pixel.MapColorFlag = GL_FALSE;
 805       ctx->Pixel.MapStencilFlag = GL_FALSE;
 806       ctx->Pixel.MapStoSsize = 1;
 807       ctx->Pixel.MapItoIsize = 1;
 808       ctx->Pixel.MapItoRsize = 1;
 809       ctx->Pixel.MapItoGsize = 1;
 810       ctx->Pixel.MapItoBsize = 1;
 811       ctx->Pixel.MapItoAsize = 1;
 812       ctx->Pixel.MapRtoRsize = 1;
 813       ctx->Pixel.MapGtoGsize = 1;
 814       ctx->Pixel.MapBtoBsize = 1;
 815       ctx->Pixel.MapAtoAsize = 1;
 816       ctx->Pixel.MapStoS[0] = 0;
 817       ctx->Pixel.MapItoI[0] = 0;
 818       ctx->Pixel.MapItoR[0] = 0.0;
 819       ctx->Pixel.MapItoG[0] = 0.0;
 820       ctx->Pixel.MapItoB[0] = 0.0;
 821       ctx->Pixel.MapItoA[0] = 0.0;
 822       ctx->Pixel.MapItoR8[0] = 0;
 823       ctx->Pixel.MapItoG8[0] = 0;
 824       ctx->Pixel.MapItoB8[0] = 0;
 825       ctx->Pixel.MapItoA8[0] = 0;
 826       ctx->Pixel.MapRtoR[0] = 0.0;
 827       ctx->Pixel.MapGtoG[0] = 0.0;
 828       ctx->Pixel.MapBtoB[0] = 0.0;
 829       ctx->Pixel.MapAtoA[0] = 0.0;
 830
 831       /* Point group */
 832       ctx->Point.SmoothFlag = GL_FALSE;
 833       ctx->Point.Size = 1.0;
 834       ctx->Point.Params[0] = 1.0;
 835       ctx->Point.Params[1] = 0.0;
 836       ctx->Point.Params[2] = 0.0;
 837       ctx->Point.Attenuated = GL_FALSE;
 838       ctx->Point.MinSize = 0.0;
 839       ctx->Point.MaxSize = (GLfloat) MAX_POINT_SIZE;
 840       ctx->Point.Threshold = 1.0;
 841
 842       /* Polygon group */
 843       ctx->Polygon.CullFlag = GL_FALSE;
 844       ctx->Polygon.CullFaceMode = GL_BACK;
 845       ctx->Polygon.FrontFace = GL_CCW;
 846       ctx->Polygon.FrontBit = 0;
 847       ctx->Polygon.FrontMode = GL_FILL;
 848       ctx->Polygon.BackMode = GL_FILL;
 849       ctx->Polygon.Unfilled = GL_FALSE;
 850       ctx->Polygon.SmoothFlag = GL_FALSE;
 851       ctx->Polygon.StippleFlag = GL_FALSE;
 852       ctx->Polygon.OffsetFactor = 0.0F;
 853       ctx->Polygon.OffsetUnits = 0.0F;
 854       ctx->Polygon.OffsetPoint = GL_FALSE;
 855       ctx->Polygon.OffsetLine = GL_FALSE;
 856       ctx->Polygon.OffsetFill = GL_FALSE;
 857
 858       /* Polygon Stipple group */
 859       MEMSET( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) );
 860
 861       /* Scissor group */
 862       ctx->Scissor.Enabled = GL_FALSE;
 863       ctx->Scissor.X = 0;
 864       ctx->Scissor.Y = 0;
 865       ctx->Scissor.Width = 0;
 866       ctx->Scissor.Height = 0;
 867
 868       /* Stencil group */
 869       ctx->Stencil.Enabled = GL_FALSE;
 870       ctx->Stencil.Function = GL_ALWAYS;
 871       ctx->Stencil.FailFunc = GL_KEEP;
 872       ctx->Stencil.ZPassFunc = GL_KEEP;
 873       ctx->Stencil.ZFailFunc = GL_KEEP;
 874       ctx->Stencil.Ref = 0;
 875       ctx->Stencil.ValueMask = 0xff;
 876       ctx->Stencil.Clear = 0;
 877       ctx->Stencil.WriteMask = 0xff;
 878
 879       /* Texture group */
 880       ctx->Texture.CurrentUnit = 0;      /* multitexture */
 881       ctx->Texture.CurrentTransformUnit = 0; /* multitexture */
 882       ctx->Texture.Enabled = 0;
 883
 884       for (i=0; i<MAX_TEXTURE_UNITS; i++)
 885          init_texture_unit( ctx, i );
 886
 887       init_color_table(&ctx->Texture.Palette);
 888
 889       /* Transformation group */
 890       ctx->Transform.MatrixMode = GL_MODELVIEW;
 891       ctx->Transform.Normalize = GL_FALSE;
 892       ctx->Transform.RescaleNormals = GL_FALSE;
 893       for (i=0;i<MAX_CLIP_PLANES;i++) {
 894          ctx->Transform.ClipEnabled[i] = GL_FALSE;
 895          ASSIGN_4V( ctx->Transform.EyeUserPlane[i], 0.0, 0.0, 0.0, 0.0 );
 896       }
 897       ctx->Transform.AnyClip = GL_FALSE;
 898
 899       /* Viewport group */
 900       ctx->Viewport.X = 0;
 901       ctx->Viewport.Y = 0;
 902       ctx->Viewport.Width = 0;
 903       ctx->Viewport.Height = 0;
 904       ctx->Viewport.Near = 0.0;
 905       ctx->Viewport.Far = 1.0;
 906       gl_matrix_ctr(&ctx->Viewport.WindowMap);
 907
 908 #define Sz 10
 909 #define Tz 14
 910       ctx->Viewport.WindowMap.m[Sz] = 0.5 * DEPTH_SCALE;
 911       ctx->Viewport.WindowMap.m[Tz] = 0.5 * DEPTH_SCALE;
 912 #undef Sz
 913 #undef Tz
 914
 915       ctx->Viewport.WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
 916       ctx->Viewport.WindowMap.type = MATRIX_3D_NO_ROT;
 917
 918       /* Vertex arrays */
 919       ctx->Array.Vertex.Size = 4;
 920       ctx->Array.Vertex.Type = GL_FLOAT;
 921       ctx->Array.Vertex.Stride = 0;
 922       ctx->Array.Vertex.StrideB = 0;
 923       ctx->Array.Vertex.Ptr = NULL;
 924       ctx->Array.Vertex.Enabled = GL_FALSE;
 925       ctx->Array.Normal.Type = GL_FLOAT;
 926       ctx->Array.Normal.Stride = 0;
 927       ctx->Array.Normal.StrideB = 0;
 928       ctx->Array.Normal.Ptr = NULL;
 929       ctx->Array.Normal.Enabled = GL_FALSE;
 930       ctx->Array.Color.Size = 4;
 931       ctx->Array.Color.Type = GL_FLOAT;
 932       ctx->Array.Color.Stride = 0;
 933       ctx->Array.Color.StrideB = 0;
 934       ctx->Array.Color.Ptr = NULL;
 935       ctx->Array.Color.Enabled = GL_FALSE;
 936       ctx->Array.Index.Type = GL_FLOAT;
 937       ctx->Array.Index.Stride = 0;
 938       ctx->Array.Index.StrideB = 0;
 939       ctx->Array.Index.Ptr = NULL;
 940       ctx->Array.Index.Enabled = GL_FALSE;
 941       for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
 942          ctx->Array.TexCoord[i].Size = 4;
 943          ctx->Array.TexCoord[i].Type = GL_FLOAT;
 944          ctx->Array.TexCoord[i].Stride = 0;
 945          ctx->Array.TexCoord[i].StrideB = 0;
 946          ctx->Array.TexCoord[i].Ptr = NULL;
 947          ctx->Array.TexCoord[i].Enabled = GL_FALSE;
 948       }
 949       ctx->Array.TexCoordInterleaveFactor = 1;
 950       ctx->Array.EdgeFlag.Stride = 0;
 951       ctx->Array.EdgeFlag.StrideB = 0;
 952       ctx->Array.EdgeFlag.Ptr = NULL;
 953       ctx->Array.EdgeFlag.Enabled = GL_FALSE;
 954       ctx->Array.ActiveTexture = 0;   /* GL_ARB_multitexture */
 955
 956       /* Pixel transfer */
 957       ctx->Pack.Alignment = 4;
 958       ctx->Pack.RowLength = 0;
 959       ctx->Pack.ImageHeight = 0;
 960       ctx->Pack.SkipPixels = 0;
 961       ctx->Pack.SkipRows = 0;
 962       ctx->Pack.SkipImages = 0;
 963       ctx->Pack.SwapBytes = GL_FALSE;
 964       ctx->Pack.LsbFirst = GL_FALSE;
 965       ctx->Unpack.Alignment = 4;
 966       ctx->Unpack.RowLength = 0;
 967       ctx->Unpack.ImageHeight = 0;
 968       ctx->Unpack.SkipPixels = 0;
 969       ctx->Unpack.SkipRows = 0;
 970       ctx->Unpack.SkipImages = 0;
 971       ctx->Unpack.SwapBytes = GL_FALSE;
 972       ctx->Unpack.LsbFirst = GL_FALSE;
 973
 974       /* Feedback */
 975       ctx->Feedback.Type = GL_2D;   /* TODO: verify */
 976       ctx->Feedback.Buffer = NULL;
 977       ctx->Feedback.BufferSize = 0;
 978       ctx->Feedback.Count = 0;
 979
 980       /* Selection/picking */
 981       ctx->Select.Buffer = NULL;
 982       ctx->Select.BufferSize = 0;
 983       ctx->Select.BufferCount = 0;
 984       ctx->Select.Hits = 0;
 985       ctx->Select.NameStackDepth = 0;
 986
 987       /* Optimized Accum buffer */
 988       ctx->IntegerAccumMode = GL_TRUE;
 989       ctx->IntegerAccumScaler = 0.0;
 990
 991       /* Renderer and client attribute stacks */
 992       ctx->AttribStackDepth = 0;
 993       ctx->ClientAttribStackDepth = 0;
 994
 995       /*** Miscellaneous ***/
 996       ctx->NewState = NEW_ALL;
 997       ctx->RenderMode = GL_RENDER;
 998       ctx->StippleCounter = 0;
 999       ctx->NeedNormals = GL_FALSE;
1000       ctx->DoViewportMapping = GL_TRUE;
1001
1002       ctx->NeedEyeCoords = GL_FALSE;
1003       ctx->NeedEyeNormals = GL_FALSE;
1004       ctx->vb_proj_matrix = &ctx->ModelProjectMatrix;
1005
1006       /* Display list */
1007       ctx->CallDepth = 0;
1008       ctx->ExecuteFlag = GL_TRUE;
1009       ctx->CompileFlag = GL_FALSE;
1010       ctx->CurrentListPtr = NULL;
1011       ctx->CurrentBlock = NULL;
1012       ctx->CurrentListNum = 0;
1013       ctx->CurrentPos = 0;
1014
1015       ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1016
1017       ctx->CatchSignals = GL_TRUE;
1018
1019       /* For debug/development only */
1020       ctx->NoRaster = getenv("MESA_NO_RASTER") ? GL_TRUE : GL_FALSE;
1021       ctx->FirstTimeCurrent = GL_TRUE;
1022
1023       /* Dither disable */
1024       ctx->NoDither = getenv("MESA_NO_DITHER") ? GL_TRUE : GL_FALSE;
1025       if (ctx->NoDither) {
1026          if (getenv("MESA_DEBUG")) {
1027             fprintf(stderr, "MESA_NO_DITHER set - dithering disabled\n");
1028          }
1029          ctx->Color.DitherFlag = GL_FALSE;
1030       }
1031    }
1032 }
1033
1034
1035
1036 /*
1037  * Allocate a new GLvisual object.
1038  * Input:  rgbFlag - GL_TRUE=RGB(A) mode, GL_FALSE=Color Index mode
1039  *         alphaFlag - alloc software alpha buffers?
1040  *         dbFlag - double buffering?
1041  *         stereoFlag - stereo buffer?
1042  *         depthFits - requested minimum bits per depth buffer value
1043  *         stencilFits - requested minimum bits per stencil buffer value
1044  *         accumFits - requested minimum bits per accum buffer component
1045  *         indexFits - number of bits per pixel if rgbFlag==GL_FALSE
1046  *         red/green/blue/alphaFits - number of bits per color component
1047  *                                     in frame buffer for RGB(A) mode.
1048  * Return:  pointer to new GLvisual or NULL if requested parameters can't
1049  *          be met.
1050  */
1051 GLvisual *gl_create_visual( GLboolean rgbFlag,
1052                             GLboolean alphaFlag,
1053                             GLboolean dbFlag,
1054                             GLboolean stereoFlag,
1055                             GLint depthBits,
1056                             GLint stencilBits,
1057                             GLint accumBits,
1058                             GLint indexBits,
1059                             GLint redBits,
1060                             GLint greenBits,
1061                             GLint blueBits,
1062                             GLint alphaBits )
1063 {
1064    GLvisual *vis;
1065
1066    if (depthBits > (GLint) (8*sizeof(GLdepth))) {
1067       /* can't meet depth buffer requirements */
1068       return NULL;
1069    }
1070    if (stencilBits > (GLint) (8*sizeof(GLstencil))) {
1071       /* can't meet stencil buffer requirements */
1072       return NULL;
1073    }
1074    if (accumBits > (GLint) (8*sizeof(GLaccum))) {
1075       /* can't meet accum buffer requirements */
1076       return NULL;
1077    }
1078
1079    vis = (GLvisual *) CALLOC( sizeof(GLvisual) );
1080    if (!vis) {
1081       return NULL;
1082    }
1083
1084    vis->RGBAflag   = rgbFlag;
1085    vis->DBflag     = dbFlag;
1086    vis->StereoFlag = stereoFlag;
1087    vis->RedBits    = redBits;
1088    vis->GreenBits  = greenBits;
1089    vis->BlueBits   = blueBits;
1090    vis->AlphaBits  = alphaFlag ? 8*sizeof(GLubyte) : alphaBits;
1091
1092    vis->IndexBits   = indexBits;
1093    vis->DepthBits   = (depthBits>0) ? 8*sizeof(GLdepth) : 0;
1094    vis->AccumBits   = (accumBits>0) ? 8*sizeof(GLaccum) : 0;
1095    vis->StencilBits = (stencilBits>0) ? 8*sizeof(GLstencil) : 0;
1096
1097    vis->SoftwareAlpha = alphaFlag;
1098
1099    return vis;
1100 }
1101
1102
1103
1104 void gl_destroy_visual( GLvisual *vis )
1105 {
1106    FREE( vis );
1107 }
1108
1109
1110
1111 /*
1112  * Allocate the proxy textures.  If we run out of memory part way through
1113  * the allocations clean up and return GL_FALSE.
1114  * Return:  GL_TRUE=success, GL_FALSE=failure
1115  */
1116 static GLboolean alloc_proxy_textures( GLcontext *ctx )
1117 {
1118    GLboolean out_of_memory;
1119    GLint i;
1120
1121    ctx->Texture.Proxy1D = gl_alloc_texture_object(NULL, 0, 1);
1122    if (!ctx->Texture.Proxy1D) {
1123       return GL_FALSE;
1124    }
1125
1126    ctx->Texture.Proxy2D = gl_alloc_texture_object(NULL, 0, 2);
1127    if (!ctx->Texture.Proxy2D) {
1128       gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
1129       return GL_FALSE;
1130    }
1131
1132    ctx->Texture.Proxy3D = gl_alloc_texture_object(NULL, 0, 3);
1133    if (!ctx->Texture.Proxy3D) {
1134       gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
1135       gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
1136       return GL_FALSE;
1137    }
1138
1139    out_of_memory = GL_FALSE;
1140    for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1141       ctx->Texture.Proxy1D->Image[i] = gl_alloc_texture_image();
1142       ctx->Texture.Proxy2D->Image[i] = gl_alloc_texture_image();
1143       ctx->Texture.Proxy3D->Image[i] = gl_alloc_texture_image();
1144       if (!ctx->Texture.Proxy1D->Image[i]
1145           || !ctx->Texture.Proxy2D->Image[i]
1146           || !ctx->Texture.Proxy3D->Image[i]) {
1147          out_of_memory = GL_TRUE;
1148       }
1149    }
1150    if (out_of_memory) {
1151       for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1152          if (ctx->Texture.Proxy1D->Image[i]) {
1153             gl_free_texture_image(ctx->Texture.Proxy1D->Image[i]);
1154          }
1155          if (ctx->Texture.Proxy2D->Image[i]) {
1156             gl_free_texture_image(ctx->Texture.Proxy2D->Image[i]);
1157          }
1158          if (ctx->Texture.Proxy3D->Image[i]) {
1159             gl_free_texture_image(ctx->Texture.Proxy3D->Image[i]);
1160          }
1161       }
1162       gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
1163       gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
1164       gl_free_texture_object(NULL, ctx->Texture.Proxy3D);
1165       return GL_FALSE;
1166    }
1167    else {
1168       return GL_TRUE;
1169    }
1170 }
1171
1172
1173
1174 /*
1175  * Allocate and initialize a GLcontext structure.
1176  * Input:  visual - a GLvisual pointer
1177  *         sharelist - another context to share display lists with or NULL
1178  *         driver_ctx - pointer to device driver's context state struct
1179  * Return:  pointer to a new gl_context struct or NULL if error.
1180  */
1181 GLcontext *gl_create_context( GLvisual *visual,
1182                               GLcontext *share_list,
1183                               void *driver_ctx,
1184                               GLboolean direct )
1185 {
1186    GLcontext *ctx;
1187    GLuint i;
1188
1189    (void) direct;  /* not used */
1190
1191    /* do some implementation tests */
1192    assert( sizeof(GLbyte) == 1 );
1193    assert( sizeof(GLshort) >= 2 );
1194    assert( sizeof(GLint) >= 4 );
1195    assert( sizeof(GLubyte) == 1 );
1196    assert( sizeof(GLushort) >= 2 );
1197    assert( sizeof(GLuint) >= 4 );
1198
1199    /* misc one-time initializations */
1200    one_time_init();
1201
1202    ctx = (GLcontext *) CALLOC( sizeof(GLcontext) );
1203    if (!ctx) {
1204       return NULL;
1205    }
1206
1207    ctx->DriverCtx = driver_ctx;
1208    ctx->Visual = visual;
1209    ctx->DrawBuffer = NULL;
1210    ctx->ReadBuffer = NULL;
1211
1212    ctx->VB = gl_vb_create_for_immediate( ctx );
1213    if (!ctx->VB) {
1214       FREE( ctx );
1215       return NULL;
1216    }
1217    ctx->input = ctx->VB->IM;
1218
1219    ctx->PB = gl_alloc_pb();
1220    if (!ctx->PB) {
1221       FREE( ctx->VB );
1222       FREE( ctx );
1223       return NULL;
1224    }
1225
1226    if (share_list) {
1227       /* share the group of display lists of another context */
1228       ctx->Shared = share_list->Shared;
1229    }
1230    else {
1231       /* allocate new group of display lists */
1232       ctx->Shared = alloc_shared_state();
1233       if (!ctx->Shared) {
1234          FREE(ctx->VB);
1235          FREE(ctx->PB);
1236          FREE(ctx);
1237          return NULL;
1238       }
1239    }
1240    ctx->Shared->RefCount++;
1241
1242    initialize_context( ctx );
1243    gl_reset_vb( ctx->VB );
1244    gl_reset_input( ctx );
1245
1246
1247    ctx->ShineTabList = MALLOC_STRUCT( gl_shine_tab );
1248    make_empty_list( ctx->ShineTabList );
1249
1250    for (i = 0 ; i < 10 ; i++) {
1251       struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab );
1252       s->shininess = -1;
1253       s->refcount = 0;
1254       insert_at_tail( ctx->ShineTabList, s );
1255    }
1256
1257    for (i = 0 ; i < 4 ; i++) {
1258       ctx->ShineTable[i] = ctx->ShineTabList->prev;
1259       ctx->ShineTable[i]->refcount++;
1260    }
1261
1262    if (visual->DBflag) {
1263       ctx->Color.DrawBuffer = GL_BACK;
1264       ctx->Color.DriverDrawBuffer = GL_BACK_LEFT;
1265       ctx->Color.DrawDestMask = BACK_LEFT_BIT;
1266       ctx->Pixel.ReadBuffer = GL_BACK;
1267       ctx->Pixel.DriverReadBuffer = GL_BACK_LEFT;
1268    }
1269    else {
1270       ctx->Color.DrawBuffer = GL_FRONT;
1271       ctx->Color.DriverDrawBuffer = GL_FRONT_LEFT;
1272       ctx->Color.DrawDestMask = FRONT_LEFT_BIT;
1273       ctx->Pixel.ReadBuffer = GL_FRONT;
1274       ctx->Pixel.DriverReadBuffer = GL_FRONT_LEFT;
1275    }
1276
1277
1278    /* Fill in some driver defaults now.
1279     */
1280    ctx->Driver.AllocDepthBuffer = gl_alloc_depth_buffer;
1281    ctx->Driver.ReadDepthSpanFloat = gl_read_depth_span_float;
1282    ctx->Driver.ReadDepthSpanInt = gl_read_depth_span_int;
1283
1284
1285 #ifdef PROFILE
1286    init_timings( ctx );
1287 #endif
1288
1289    if (!alloc_proxy_textures(ctx)) {
1290       free_shared_state(ctx, ctx->Shared);
1291       FREE(ctx->VB);
1292       FREE(ctx->PB);
1293       FREE(ctx);
1294       return NULL;
1295    }
1296
1297    /* setup API dispatch tables */
1298    _mesa_init_exec_table( &ctx->Exec );
1299    _mesa_init_dlist_table( &ctx->Save );
1300    ctx->CurrentDispatch = &ctx->Exec;
1301
1302    return ctx;
1303 }
1304
1305 /* Just reads the config files...
1306  */
1307 void gl_context_initialize( GLcontext *ctx )
1308 {
1309    gl_read_config_file( ctx );
1310 }
1311
1312
1313
1314
1315 /*
1316  * Destroy a gl_context structure.
1317  */
1318 void gl_destroy_context( GLcontext *ctx )
1319 {
1320    if (ctx) {
1321
1322       GLuint i;
1323       struct gl_shine_tab *s, *tmps;
1324
1325 #ifdef PROFILE
1326       if (getenv("MESA_PROFILE")) {
1327          print_timings( ctx );
1328       }
1329 #endif
1330
1331       gl_matrix_dtr( &ctx->ModelView );
1332       for (i = 0 ; i < MAX_MODELVIEW_STACK_DEPTH ; i++) {
1333          gl_matrix_dtr( &ctx->ModelViewStack[i] );
1334       }
1335       gl_matrix_dtr( &ctx->ProjectionMatrix );
1336       for (i = 0 ; i < MAX_PROJECTION_STACK_DEPTH ; i++) {
1337          gl_matrix_dtr( &ctx->ProjectionStack[i] );
1338       }
1339
1340       FREE( ctx->PB );
1341
1342       if(ctx->input != ctx->VB->IM)
1343          gl_immediate_free( ctx->input );
1344
1345       gl_vb_free( ctx->VB );
1346
1347       ctx->Shared->RefCount--;
1348       assert(ctx->Shared->RefCount>=0);
1349       if (ctx->Shared->RefCount==0) {
1350          /* free shared state */
1351          free_shared_state( ctx, ctx->Shared );
1352       }
1353
1354       foreach_s( s, tmps, ctx->ShineTabList ) {
1355          FREE( s );
1356       }
1357       FREE( ctx->ShineTabList );
1358
1359       /* Free proxy texture objects */
1360       gl_free_texture_object( NULL, ctx->Texture.Proxy1D );
1361       gl_free_texture_object( NULL, ctx->Texture.Proxy2D );
1362       gl_free_texture_object( NULL, ctx->Texture.Proxy3D );
1363
1364       /* Free evaluator data */
1365       if (ctx->EvalMap.Map1Vertex3.Points)
1366          FREE( ctx->EvalMap.Map1Vertex3.Points );
1367       if (ctx->EvalMap.Map1Vertex4.Points)
1368          FREE( ctx->EvalMap.Map1Vertex4.Points );
1369       if (ctx->EvalMap.Map1Index.Points)
1370          FREE( ctx->EvalMap.Map1Index.Points );
1371       if (ctx->EvalMap.Map1Color4.Points)
1372          FREE( ctx->EvalMap.Map1Color4.Points );
1373       if (ctx->EvalMap.Map1Normal.Points)
1374          FREE( ctx->EvalMap.Map1Normal.Points );
1375       if (ctx->EvalMap.Map1Texture1.Points)
1376          FREE( ctx->EvalMap.Map1Texture1.Points );
1377       if (ctx->EvalMap.Map1Texture2.Points)
1378          FREE( ctx->EvalMap.Map1Texture2.Points );
1379       if (ctx->EvalMap.Map1Texture3.Points)
1380          FREE( ctx->EvalMap.Map1Texture3.Points );
1381       if (ctx->EvalMap.Map1Texture4.Points)
1382          FREE( ctx->EvalMap.Map1Texture4.Points );
1383
1384       if (ctx->EvalMap.Map2Vertex3.Points)
1385          FREE( ctx->EvalMap.Map2Vertex3.Points );
1386       if (ctx->EvalMap.Map2Vertex4.Points)
1387          FREE( ctx->EvalMap.Map2Vertex4.Points );
1388       if (ctx->EvalMap.Map2Index.Points)
1389          FREE( ctx->EvalMap.Map2Index.Points );
1390       if (ctx->EvalMap.Map2Color4.Points)
1391          FREE( ctx->EvalMap.Map2Color4.Points );
1392       if (ctx->EvalMap.Map2Normal.Points)
1393          FREE( ctx->EvalMap.Map2Normal.Points );
1394       if (ctx->EvalMap.Map2Texture1.Points)
1395          FREE( ctx->EvalMap.Map2Texture1.Points );
1396       if (ctx->EvalMap.Map2Texture2.Points)
1397          FREE( ctx->EvalMap.Map2Texture2.Points );
1398       if (ctx->EvalMap.Map2Texture3.Points)
1399          FREE( ctx->EvalMap.Map2Texture3.Points );
1400       if (ctx->EvalMap.Map2Texture4.Points)
1401          FREE( ctx->EvalMap.Map2Texture4.Points );
1402
1403       /* Free cache of immediate buffers. */
1404       while (ctx->nr_im_queued-- > 0) {
1405          struct immediate * next = ctx->freed_im_queue->next;
1406          FREE( ctx->freed_im_queue );
1407          ctx->freed_im_queue = next;
1408       }
1409       gl_extensions_dtr(ctx);
1410
1411       FREE( (void *) ctx );
1412
1413 #ifndef THREADS
1414       if (ctx == _mesa_current_context) {
1415          _mesa_current_context = NULL;
1416          CURRENT_INPUT = NULL;
1417       }
1418 #endif
1419
1420    }
1421 }
1422
1423
1424
1425 /*
1426  * Create a new framebuffer.  A GLframebuffer is a struct which
1427  * encapsulates the depth, stencil and accum buffers and related
1428  * parameters.
1429  * Input:  visual - a GLvisual pointer
1430  * Return:  pointer to new GLframebuffer struct or NULL if error.
1431  */
1432 GLframebuffer *gl_create_framebuffer( GLvisual *visual )
1433 {
1434    GLframebuffer *buffer;
1435
1436    buffer = (GLframebuffer *) CALLOC( sizeof(GLframebuffer) );
1437    if (!buffer) {
1438       return NULL;
1439    }
1440
1441    buffer->Visual = visual;
1442
1443    return buffer;
1444 }
1445
1446
1447
1448 /*
1449  * Free a framebuffer struct and its buffers.
1450  */
1451 void gl_destroy_framebuffer( GLframebuffer *buffer )
1452 {
1453    if (buffer) {
1454       if (buffer->Depth) {
1455          FREE( buffer->Depth );
1456       }
1457       if (buffer->Accum) {
1458          FREE( buffer->Accum );
1459       }
1460       if (buffer->Stencil) {
1461          FREE( buffer->Stencil );
1462       }
1463       if (buffer->FrontLeftAlpha) {
1464          FREE( buffer->FrontLeftAlpha );
1465       }
1466       if (buffer->BackLeftAlpha) {
1467          FREE( buffer->BackLeftAlpha );
1468       }
1469       if (buffer->FrontRightAlpha) {
1470          FREE( buffer->FrontRightAlpha );
1471       }
1472       if (buffer->BackRightAlpha) {
1473          FREE( buffer->BackRightAlpha );
1474       }
1475       FREE(buffer);
1476    }
1477 }
1478
1479
1480
1481 /*
1482  * Set the current context, binding the given frame buffer to the context.
1483  */
1484 void gl_make_current( GLcontext *newCtx, GLframebuffer *buffer )
1485 {
1486    gl_make_current2( newCtx, buffer, buffer );
1487 }
1488
1489
1490 /*
1491  * Bind the given context to the given draw-buffer and read-buffer
1492  * and make it the current context for this thread.
1493  */
1494 void gl_make_current2( GLcontext *newCtx, GLframebuffer *drawBuffer,
1495                        GLframebuffer *readBuffer )
1496 {
1497    GET_CURRENT_CONTEXT(oldCtx);
1498
1499    /* Flush the old context
1500     */
1501    if (oldCtx) {
1502       ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(oldCtx, "gl_make_current");
1503    }
1504
1505    /* unbind frame buffers from context */
1506    if (oldCtx && oldCtx->DrawBuffer) {
1507       oldCtx->DrawBuffer = NULL;
1508    }
1509    if (oldCtx && oldCtx->ReadBuffer) {
1510       oldCtx->ReadBuffer = NULL;
1511    }
1512
1513 #ifdef THREADS
1514    /* TODO: unbind old buffer from context? */
1515    MesaSetTSD(&mesa_ctx_tsd, (void *) newCtx, mesa_ctx_thread_init);
1516 #else
1517    _mesa_current_context = newCtx;
1518 #endif
1519    if (newCtx) {
1520       SET_IMMEDIATE(newCtx, newCtx->input);
1521    }
1522
1523    if (newCtx)
1524       _glapi_set_dispatch(newCtx->CurrentDispatch);
1525    else
1526       _glapi_set_dispatch(NULL);  /* none current */
1527
1528    if (MESA_VERBOSE) fprintf(stderr, "gl_make_current()\n");
1529
1530    if (newCtx && drawBuffer && readBuffer) {
1531       /* TODO: check if newCtx and buffer's visual match??? */
1532       newCtx->DrawBuffer = drawBuffer;
1533       newCtx->ReadBuffer = readBuffer;
1534       newCtx->NewState = NEW_ALL;   /* just to be safe */
1535       gl_update_state( newCtx );
1536    }
1537
1538    /* We can use this to help debug user's problems.  Tell the to set
1539     * the MESA_INFO env variable before running their app.  Then the
1540     * first time each context is made current we'll print some useful
1541     * information.
1542     */
1543    if (newCtx && newCtx->FirstTimeCurrent) {
1544       if (getenv("MESA_INFO")) {
1545          fprintf(stderr, "Mesa GL_VERSION = %s\n", (char *) _mesa_GetString(GL_VERSION));
1546          fprintf(stderr, "Mesa GL_RENDERER = %s\n", (char *) _mesa_GetString(GL_RENDERER));
1547          fprintf(stderr, "Mesa GL_VENDOR = %s\n", (char *) _mesa_GetString(GL_VENDOR));
1548          fprintf(stderr, "Mesa GL_EXTENSIONS = %s\n", (char *) _mesa_GetString(GL_EXTENSIONS));
1549       }
1550       newCtx->FirstTimeCurrent = GL_FALSE;
1551    }
1552 }
1553
1554
1555
1556 /*
1557  * Return current context handle for the calling thread.
1558  */
1559 GLcontext *gl_get_current_context( void )
1560 {
1561 #ifdef THREADS
1562    return (GLcontext *) MesaGetTSD(&mesa_ctx_tsd);
1563 #else
1564    return _mesa_current_context;
1565 #endif
1566 }
1567
1568
1569
1570 /*
1571  * Copy attribute groups from one context to another.
1572  * Input:  src - source context
1573  *         dst - destination context
1574  *         mask - bitwise OR of GL_*_BIT flags
1575  */
1576 void gl_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1577 {
1578    if (mask & GL_ACCUM_BUFFER_BIT) {
1579       MEMCPY( &dst->Accum, &src->Accum, sizeof(struct gl_accum_attrib) );
1580    }
1581    if (mask & GL_COLOR_BUFFER_BIT) {
1582       MEMCPY( &dst->Color, &src->Color, sizeof(struct gl_colorbuffer_attrib) );
1583    }
1584    if (mask & GL_CURRENT_BIT) {
1585       MEMCPY( &dst->Current, &src->Current, sizeof(struct gl_current_attrib) );
1586    }
1587    if (mask & GL_DEPTH_BUFFER_BIT) {
1588       MEMCPY( &dst->Depth, &src->Depth, sizeof(struct gl_depthbuffer_attrib) );
1589    }
1590    if (mask & GL_ENABLE_BIT) {
1591       /* no op */
1592    }
1593    if (mask & GL_EVAL_BIT) {
1594       MEMCPY( &dst->Eval, &src->Eval, sizeof(struct gl_eval_attrib) );
1595    }
1596    if (mask & GL_FOG_BIT) {
1597       MEMCPY( &dst->Fog, &src->Fog, sizeof(struct gl_fog_attrib) );
1598    }
1599    if (mask & GL_HINT_BIT) {
1600       MEMCPY( &dst->Hint, &src->Hint, sizeof(struct gl_hint_attrib) );
1601    }
1602    if (mask & GL_LIGHTING_BIT) {
1603       MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light_attrib) );
1604 /*       gl_reinit_light_attrib( &dst->Light ); */
1605    }
1606    if (mask & GL_LINE_BIT) {
1607       MEMCPY( &dst->Line, &src->Line, sizeof(struct gl_line_attrib) );
1608    }
1609    if (mask & GL_LIST_BIT) {
1610       MEMCPY( &dst->List, &src->List, sizeof(struct gl_list_attrib) );
1611    }
1612    if (mask & GL_PIXEL_MODE_BIT) {
1613       MEMCPY( &dst->Pixel, &src->Pixel, sizeof(struct gl_pixel_attrib) );
1614    }
1615    if (mask & GL_POINT_BIT) {
1616       MEMCPY( &dst->Point, &src->Point, sizeof(struct gl_point_attrib) );
1617    }
1618    if (mask & GL_POLYGON_BIT) {
1619       MEMCPY( &dst->Polygon, &src->Polygon, sizeof(struct gl_polygon_attrib) );
1620    }
1621    if (mask & GL_POLYGON_STIPPLE_BIT) {
1622       /* Use loop instead of MEMCPY due to problem with Portland Group's
1623        * C compiler.  Reported by John Stone.
1624        */
1625       int i;
1626       for (i=0;i<32;i++) {
1627          dst->PolygonStipple[i] = src->PolygonStipple[i];
1628       }
1629    }
1630    if (mask & GL_SCISSOR_BIT) {
1631       MEMCPY( &dst->Scissor, &src->Scissor, sizeof(struct gl_scissor_attrib) );
1632    }
1633    if (mask & GL_STENCIL_BUFFER_BIT) {
1634       MEMCPY( &dst->Stencil, &src->Stencil, sizeof(struct gl_stencil_attrib) );
1635    }
1636    if (mask & GL_TEXTURE_BIT) {
1637       MEMCPY( &dst->Texture, &src->Texture, sizeof(struct gl_texture_attrib) );
1638    }
1639    if (mask & GL_TRANSFORM_BIT) {
1640       MEMCPY( &dst->Transform, &src->Transform, sizeof(struct gl_transform_attrib) );
1641    }
1642    if (mask & GL_VIEWPORT_BIT) {
1643       MEMCPY( &dst->Viewport, &src->Viewport, sizeof(struct gl_viewport_attrib) );
1644    }
1645 }
1646
1647
1648 /*
1649  * This should be called by device drivers just before they do a
1650  * swapbuffers.  Any pending rendering commands will be executed.
1651  */
1652 void
1653 _mesa_swapbuffers(GLcontext *ctx)
1654 {
1655    FLUSH_VB( ctx, "swap buffers" );
1656 }
1657
1658
1659 /*
1660  * Return pointer to this context's current API dispatch table.
1661  * It'll either be the immediate-mode execute dispatcher or the
1662  * display list compile dispatcher.
1663  */
1664 struct _glapi_table *
1665 _mesa_get_dispatch(GLcontext *ctx)
1666 {
1667    return ctx->CurrentDispatch;
1668 }
1669
1670
1671
1672 void
1673 _mesa_ResizeBuffersMESA( void )
1674 {
1675    GET_CURRENT_CONTEXT(ctx);
1676
1677    GLuint buf_width, buf_height;
1678
1679    if (MESA_VERBOSE & VERBOSE_API)
1680       fprintf(stderr, "glResizeBuffersMESA\n");
1681
1682    /* ask device driver for size of output buffer */
1683    (*ctx->Driver.GetBufferSize)( ctx, &buf_width, &buf_height );
1684
1685    /* see if size of device driver's color buffer (window) has changed */
1686    if (ctx->DrawBuffer->Width == (GLint) buf_width &&
1687        ctx->DrawBuffer->Height == (GLint) buf_height)
1688       return;
1689
1690    ctx->NewState |= NEW_RASTER_OPS;  /* to update scissor / window bounds */
1691
1692    /* save buffer size */
1693    ctx->DrawBuffer->Width = buf_width;
1694    ctx->DrawBuffer->Height = buf_height;
1695
1696    /* Reallocate other buffers if needed. */
1697    if (ctx->Visual->DepthBits>0) {
1698       /* reallocate depth buffer */
1699       (*ctx->Driver.AllocDepthBuffer)( ctx );
1700    }
1701    if (ctx->Visual->StencilBits>0) {
1702       /* reallocate stencil buffer */
1703       gl_alloc_stencil_buffer( ctx );
1704    }
1705    if (ctx->Visual->AccumBits>0) {
1706       /* reallocate accum buffer */
1707       gl_alloc_accum_buffer( ctx );
1708    }
1709    if (ctx->Visual->SoftwareAlpha) {
1710       gl_alloc_alpha_buffers( ctx );
1711    }
1712 }
1713
1714
1715
1716 /**********************************************************************/
1717 /*****                Miscellaneous functions                     *****/
1718 /**********************************************************************/
1719
1720
1721 /*
1722  * This function is called when the Mesa user has stumbled into a code
1723  * path which may not be implemented fully or correctly.
1724  */
1725 void gl_problem( const GLcontext *ctx, const char *s )
1726 {
1727    fprintf( stderr, "Mesa implementation error: %s\n", s );
1728    fprintf( stderr, "Report to mesa-bugs@mesa3d.org\n" );
1729    (void) ctx;
1730 }
1731
1732
1733
1734 /*
1735  * This is called to inform the user that he or she has tried to do
1736  * something illogical or if there's likely a bug in their program
1737  * (like enabled depth testing without a depth buffer).
1738  */
1739 void gl_warning( const GLcontext *ctx, const char *s )
1740 {
1741    GLboolean debug;
1742 #ifdef DEBUG
1743    debug = GL_TRUE;
1744 #else
1745    if (getenv("MESA_DEBUG")) {
1746       debug = GL_TRUE;
1747    }
1748    else {
1749       debug = GL_FALSE;
1750    }
1751 #endif
1752    if (debug) {
1753       fprintf( stderr, "Mesa warning: %s\n", s );
1754    }
1755    (void) ctx;
1756 }
1757
1758
1759
1760 void gl_compile_error( GLcontext *ctx, GLenum error, const char *s )
1761 {
1762    if (ctx->CompileFlag)
1763       gl_save_error( ctx, error, s );
1764
1765    if (ctx->ExecuteFlag)
1766       gl_error( ctx, error, s );
1767 }
1768
1769
1770 /*
1771  * This is Mesa's error handler.  Normally, all that's done is the updating
1772  * of the current error value.  If Mesa is compiled with -DDEBUG or if the
1773  * environment variable "MESA_DEBUG" is defined then a real error message
1774  * is printed to stderr.
1775  * Input:  error - the error value
1776  *         s - a diagnostic string
1777  */
1778 void gl_error( GLcontext *ctx, GLenum error, const char *s )
1779 {
1780    GLboolean debug;
1781
1782 #ifdef DEBUG
1783    debug = GL_TRUE;
1784 #else
1785    if (getenv("MESA_DEBUG")) {
1786       debug = GL_TRUE;
1787    }
1788    else {
1789       debug = GL_FALSE;
1790    }
1791 #endif
1792
1793    if (debug) {
1794       char errstr[1000];
1795
1796       switch (error) {
1797          case GL_NO_ERROR:
1798             strcpy( errstr, "GL_NO_ERROR" );
1799             break;
1800          case GL_INVALID_VALUE:
1801             strcpy( errstr, "GL_INVALID_VALUE" );
1802             break;
1803          case GL_INVALID_ENUM:
1804             strcpy( errstr, "GL_INVALID_ENUM" );
1805             break;
1806          case GL_INVALID_OPERATION:
1807             strcpy( errstr, "GL_INVALID_OPERATION" );
1808             break;
1809          case GL_STACK_OVERFLOW:
1810             strcpy( errstr, "GL_STACK_OVERFLOW" );
1811             break;
1812          case GL_STACK_UNDERFLOW:
1813             strcpy( errstr, "GL_STACK_UNDERFLOW" );
1814             break;
1815          case GL_OUT_OF_MEMORY:
1816             strcpy( errstr, "GL_OUT_OF_MEMORY" );
1817             break;
1818          default:
1819             strcpy( errstr, "unknown" );
1820             break;
1821       }
1822       fprintf( stderr, "Mesa user error: %s in %s\n", errstr, s );
1823    }
1824
1825    if (ctx->ErrorValue==GL_NO_ERROR) {
1826       ctx->ErrorValue = error;
1827    }
1828
1829    /* Call device driver's error handler, if any.  This is used on the Mac. */
1830    if (ctx->Driver.Error) {
1831       (*ctx->Driver.Error)( ctx );
1832    }
1833 }
1834
1835
1836
1837 /**********************************************************************/
1838 /*****                   State update logic                       *****/
1839 /**********************************************************************/
1840
1841
1842 /*
1843  * Since the device driver may or may not support pixel logic ops we
1844  * have to make some extensive tests to determine whether or not
1845  * software-implemented logic operations have to be used.
1846  */
1847 static void update_pixel_logic( GLcontext *ctx )
1848 {
1849    if (ctx->Visual->RGBAflag) {
1850       /* RGBA mode blending w/ Logic Op */
1851       if (ctx->Color.ColorLogicOpEnabled) {
1852          if (ctx->Driver.LogicOp
1853              && (*ctx->Driver.LogicOp)( ctx, ctx->Color.LogicOp )) {
1854             /* Device driver can do logic, don't have to do it in software */
1855             ctx->Color.SWLogicOpEnabled = GL_FALSE;
1856          }
1857          else {
1858             /* Device driver can't do logic op so we do it in software */
1859             ctx->Color.SWLogicOpEnabled = GL_TRUE;
1860          }
1861       }
1862       else {
1863          /* no logic op */
1864          if (ctx->Driver.LogicOp) {
1865             (void) (*ctx->Driver.LogicOp)( ctx, GL_COPY );
1866          }
1867          ctx->Color.SWLogicOpEnabled = GL_FALSE;
1868       }
1869    }
1870    else {
1871       /* CI mode Logic Op */
1872       if (ctx->Color.IndexLogicOpEnabled) {
1873          if (ctx->Driver.LogicOp
1874              && (*ctx->Driver.LogicOp)( ctx, ctx->Color.LogicOp )) {
1875             /* Device driver can do logic, don't have to do it in software */
1876             ctx->Color.SWLogicOpEnabled = GL_FALSE;
1877          }
1878          else {
1879             /* Device driver can't do logic op so we do it in software */
1880             ctx->Color.SWLogicOpEnabled = GL_TRUE;
1881          }
1882       }
1883       else {
1884          /* no logic op */
1885          if (ctx->Driver.LogicOp) {
1886             (void) (*ctx->Driver.LogicOp)( ctx, GL_COPY );
1887          }
1888          ctx->Color.SWLogicOpEnabled = GL_FALSE;
1889       }
1890    }
1891 }
1892
1893
1894
1895 /*
1896  * Check if software implemented RGBA or Color Index masking is needed.
1897  */
1898 static void update_pixel_masking( GLcontext *ctx )
1899 {
1900    if (ctx->Visual->RGBAflag) {
1901       GLuint *colorMask = (GLuint *) ctx->Color.ColorMask;
1902       if (*colorMask == 0xffffffff) {
1903          /* disable masking */
1904          if (ctx->Driver.ColorMask) {
1905             (void) (*ctx->Driver.ColorMask)( ctx, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
1906          }
1907          ctx->Color.SWmasking = GL_FALSE;
1908       }
1909       else {
1910          /* Ask driver to do color masking, if it can't then
1911           * do it in software
1912           */
1913          GLboolean red   = ctx->Color.ColorMask[RCOMP] ? GL_TRUE : GL_FALSE;
1914          GLboolean green = ctx->Color.ColorMask[GCOMP] ? GL_TRUE : GL_FALSE;
1915          GLboolean blue  = ctx->Color.ColorMask[BCOMP] ? GL_TRUE : GL_FALSE;
1916          GLboolean alpha = ctx->Color.ColorMask[ACOMP] ? GL_TRUE : GL_FALSE;
1917          if (ctx->Driver.ColorMask
1918              && (*ctx->Driver.ColorMask)( ctx, red, green, blue, alpha )) {
1919             ctx->Color.SWmasking = GL_FALSE;
1920          }
1921          else {
1922             ctx->Color.SWmasking = GL_TRUE;
1923          }
1924       }
1925    }
1926    else {
1927       if (ctx->Color.IndexMask==0xffffffff) {
1928          /* disable masking */
1929          if (ctx->Driver.IndexMask) {
1930             (void) (*ctx->Driver.IndexMask)( ctx, 0xffffffff );
1931          }
1932          ctx->Color.SWmasking = GL_FALSE;
1933       }
1934       else {
1935          /* Ask driver to do index masking, if it can't then
1936           * do it in software
1937           */
1938          if (ctx->Driver.IndexMask
1939              && (*ctx->Driver.IndexMask)( ctx, ctx->Color.IndexMask )) {
1940             ctx->Color.SWmasking = GL_FALSE;
1941          }
1942          else {
1943             ctx->Color.SWmasking = GL_TRUE;
1944          }
1945       }
1946    }
1947 }
1948
1949
1950 static void update_fog_mode( GLcontext *ctx )
1951 {
1952    int old_mode = ctx->FogMode;
1953
1954    if (ctx->Fog.Enabled) {
1955       if (ctx->Texture.Enabled)
1956          ctx->FogMode = FOG_FRAGMENT;
1957       else if (ctx->Hint.Fog == GL_NICEST)
1958          ctx->FogMode = FOG_FRAGMENT;
1959       else
1960          ctx->FogMode = FOG_VERTEX;
1961
1962       if (ctx->Driver.GetParameteri)
1963          if ((ctx->Driver.GetParameteri)( ctx, DD_HAVE_HARDWARE_FOG ))
1964             ctx->FogMode = FOG_FRAGMENT;
1965    }
1966    else {
1967       ctx->FogMode = FOG_NONE;
1968    }
1969
1970    if (old_mode != ctx->FogMode)
1971       ctx->NewState |= NEW_FOG;
1972 }
1973
1974
1975 /*
1976  * Recompute the value of ctx->RasterMask, etc. according to
1977  * the current context.
1978  */
1979 static void update_rasterflags( GLcontext *ctx )
1980 {
1981    ctx->RasterMask = 0;
1982
1983    if (ctx->Color.AlphaEnabled)         ctx->RasterMask |= ALPHATEST_BIT;
1984    if (ctx->Color.BlendEnabled)         ctx->RasterMask |= BLEND_BIT;
1985    if (ctx->Depth.Test)                 ctx->RasterMask |= DEPTH_BIT;
1986    if (ctx->FogMode==FOG_FRAGMENT)      ctx->RasterMask |= FOG_BIT;
1987    if (ctx->Color.SWLogicOpEnabled)     ctx->RasterMask |= LOGIC_OP_BIT;
1988    if (ctx->Scissor.Enabled)            ctx->RasterMask |= SCISSOR_BIT;
1989    if (ctx->Stencil.Enabled)            ctx->RasterMask |= STENCIL_BIT;
1990    if (ctx->Color.SWmasking)            ctx->RasterMask |= MASKING_BIT;
1991
1992    if (ctx->Visual->SoftwareAlpha && ctx->Color.ColorMask[ACOMP]
1993        && ctx->Color.DrawBuffer != GL_NONE)
1994       ctx->RasterMask |= ALPHABUF_BIT;
1995
1996    if (   ctx->Viewport.X<0
1997        || ctx->Viewport.X + ctx->Viewport.Width > ctx->DrawBuffer->Width
1998        || ctx->Viewport.Y<0
1999        || ctx->Viewport.Y + ctx->Viewport.Height > ctx->DrawBuffer->Height) {
2000       ctx->RasterMask |= WINCLIP_BIT;
2001    }
2002
2003    /* If we're not drawing to exactly one color buffer set the
2004     * MULTI_DRAW_BIT flag.  Also set it if we're drawing to no
2005     * buffers or the RGBA or CI mask disables all writes.
2006     */
2007
2008    ctx->TriangleCaps &= ~DD_MULTIDRAW;
2009
2010    if (ctx->Color.MultiDrawBuffer) {
2011       ctx->RasterMask |= MULTI_DRAW_BIT;
2012       ctx->TriangleCaps |= DD_MULTIDRAW;
2013    }
2014    else if (ctx->Color.DrawBuffer==GL_NONE) {
2015       ctx->RasterMask |= MULTI_DRAW_BIT;
2016       ctx->TriangleCaps |= DD_MULTIDRAW;
2017    }
2018    else if (ctx->Visual->RGBAflag && ctx->Color.ColorMask==0) {
2019       /* all RGBA channels disabled */
2020       ctx->RasterMask |= MULTI_DRAW_BIT;
2021       ctx->TriangleCaps |= DD_MULTIDRAW;
2022       ctx->Color.DrawDestMask = 0;
2023    }
2024    else if (!ctx->Visual->RGBAflag && ctx->Color.IndexMask==0) {
2025       /* all color index bits disabled */
2026       ctx->RasterMask |= MULTI_DRAW_BIT;
2027       ctx->TriangleCaps |= DD_MULTIDRAW;
2028       ctx->Color.DrawDestMask = 0;
2029    }
2030 }
2031
2032
2033 void gl_print_state( const char *msg, GLuint state )
2034 {
2035    fprintf(stderr,
2036            "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
2037            msg,
2038            state,
2039            (state & NEW_LIGHTING)         ? "lighting, " : "",
2040            (state & NEW_RASTER_OPS)       ? "raster-ops, " : "",
2041            (state & NEW_TEXTURING)        ? "texturing, " : "",
2042            (state & NEW_POLYGON)          ? "polygon, " : "",
2043            (state & NEW_DRVSTATE0)        ? "driver-0, " : "",
2044            (state & NEW_DRVSTATE1)        ? "driver-1, " : "",
2045            (state & NEW_DRVSTATE2)        ? "driver-2, " : "",
2046            (state & NEW_DRVSTATE3)        ? "driver-3, " : "",
2047            (state & NEW_MODELVIEW)        ? "modelview, " : "",
2048            (state & NEW_PROJECTION)       ? "projection, " : "",
2049            (state & NEW_TEXTURE_MATRIX)   ? "texture-matrix, " : "",
2050            (state & NEW_USER_CLIP)        ? "user-clip, " : "",
2051            (state & NEW_TEXTURE_ENV)      ? "texture-env, " : "",
2052            (state & NEW_CLIENT_STATE)     ? "client-state, " : "",
2053            (state & NEW_FOG)              ? "fog, " : "",
2054            (state & NEW_NORMAL_TRANSFORM) ? "normal-transform, " : "",
2055            (state & NEW_VIEWPORT)         ? "viewport, " : "",
2056            (state & NEW_TEXTURE_ENABLE)   ? "texture-enable, " : "");
2057 }
2058
2059 void gl_print_enable_flags( const char *msg, GLuint flags )
2060 {
2061    fprintf(stderr,
2062            "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s\n",
2063            msg,
2064            flags,
2065            (flags & ENABLE_TEX0)       ? "tex-0, " : "",
2066            (flags & ENABLE_TEX1)       ? "tex-1, " : "",
2067            (flags & ENABLE_LIGHT)      ? "light, " : "",
2068            (flags & ENABLE_FOG)        ? "fog, " : "",
2069            (flags & ENABLE_USERCLIP)   ? "userclip, " : "",
2070            (flags & ENABLE_TEXGEN0)    ? "tex-gen-0, " : "",
2071            (flags & ENABLE_TEXGEN1)    ? "tex-gen-1, " : "",
2072            (flags & ENABLE_TEXMAT0)    ? "tex-mat-0, " : "",
2073            (flags & ENABLE_TEXMAT1)    ? "tex-mat-1, " : "",
2074            (flags & ENABLE_NORMALIZE)  ? "normalize, " : "",
2075            (flags & ENABLE_RESCALE)    ? "rescale, " : "");
2076 }
2077
2078
2079 /*
2080  * If ctx->NewState is non-zero then this function MUST be called before
2081  * rendering any primitive.  Basically, function pointers and miscellaneous
2082  * flags are updated to reflect the current state of the state machine.
2083  */
2084 void gl_update_state( GLcontext *ctx )
2085 {
2086    GLuint i;
2087
2088    if (MESA_VERBOSE & VERBOSE_STATE)
2089       gl_print_state("", ctx->NewState);
2090
2091    if (ctx->NewState & NEW_CLIENT_STATE)
2092       gl_update_client_state( ctx );
2093
2094    if ((ctx->NewState & NEW_TEXTURE_ENABLE) &&
2095        (ctx->Enabled & ENABLE_TEX_ANY) != ctx->Texture.Enabled)
2096       ctx->NewState |= NEW_TEXTURING | NEW_RASTER_OPS;
2097
2098    if (ctx->NewState & NEW_TEXTURE_ENV) {
2099       if (ctx->Texture.Unit[0].EnvMode == ctx->Texture.Unit[0].LastEnvMode &&
2100           ctx->Texture.Unit[1].EnvMode == ctx->Texture.Unit[1].LastEnvMode)
2101          ctx->NewState &= ~NEW_TEXTURE_ENV;
2102       ctx->Texture.Unit[0].LastEnvMode = ctx->Texture.Unit[0].EnvMode;
2103       ctx->Texture.Unit[1].LastEnvMode = ctx->Texture.Unit[1].EnvMode;
2104    }
2105
2106    if (ctx->NewState & NEW_TEXTURE_MATRIX) {
2107       ctx->Enabled &= ~(ENABLE_TEXMAT0|ENABLE_TEXMAT1);
2108
2109       for (i=0; i < MAX_TEXTURE_UNITS; i++) {
2110          if (ctx->TextureMatrix[i].flags & MAT_DIRTY_ALL_OVER)
2111          {
2112             gl_matrix_analyze( &ctx->TextureMatrix[i] );
2113             ctx->TextureMatrix[i].flags &= ~MAT_DIRTY_DEPENDENTS;
2114
2115             if (ctx->Texture.Unit[i].Enabled &&
2116                 ctx->TextureMatrix[i].type != MATRIX_IDENTITY)
2117                ctx->Enabled |= ENABLE_TEXMAT0 << i;
2118          }
2119       }
2120    }
2121
2122    if (ctx->NewState & (NEW_TEXTURING | NEW_TEXTURE_ENABLE)) {
2123       ctx->Texture.NeedNormals = GL_FALSE;
2124       gl_update_dirty_texobjs(ctx);
2125       ctx->Enabled &= ~(ENABLE_TEXGEN0|ENABLE_TEXGEN1);
2126       ctx->Texture.ReallyEnabled = 0;
2127
2128       for (i=0; i < MAX_TEXTURE_UNITS; i++) {
2129          if (ctx->Texture.Unit[i].Enabled) {
2130             gl_update_texture_unit( ctx, &ctx->Texture.Unit[i] );
2131
2132             ctx->Texture.ReallyEnabled |=
2133                ctx->Texture.Unit[i].ReallyEnabled<<(i*4);
2134
2135             if (ctx->Texture.Unit[i].GenFlags != 0) {
2136                ctx->Enabled |= ENABLE_TEXGEN0 << i;
2137
2138                if (ctx->Texture.Unit[i].GenFlags & TEXGEN_NEED_NORMALS)
2139                {
2140                   ctx->Texture.NeedNormals = GL_TRUE;
2141                   ctx->Texture.NeedEyeCoords = GL_TRUE;
2142                }
2143
2144                if (ctx->Texture.Unit[i].GenFlags & TEXGEN_NEED_EYE_COORD)
2145                {
2146                   ctx->Texture.NeedEyeCoords = GL_TRUE;
2147                }
2148             }
2149          }
2150       }
2151
2152       ctx->Texture.Enabled = ctx->Enabled & ENABLE_TEX_ANY;
2153       ctx->NeedNormals = (ctx->Light.Enabled || ctx->Texture.NeedNormals);
2154    }
2155
2156    if (ctx->NewState & (NEW_RASTER_OPS | NEW_LIGHTING | NEW_FOG)) {
2157
2158
2159       if (ctx->NewState & NEW_RASTER_OPS) {
2160          update_pixel_logic(ctx);
2161          update_pixel_masking(ctx);
2162          update_fog_mode(ctx);
2163          update_rasterflags(ctx);
2164          if (ctx->Driver.Dither) {
2165             (*ctx->Driver.Dither)( ctx, ctx->Color.DitherFlag );
2166          }
2167
2168          /* Check if incoming colors can be modified during rasterization */
2169          if (ctx->Fog.Enabled ||
2170              ctx->Texture.Enabled ||
2171              ctx->Color.BlendEnabled ||
2172              ctx->Color.SWmasking ||
2173              ctx->Color.SWLogicOpEnabled) {
2174             ctx->MutablePixels = GL_TRUE;
2175          }
2176          else {
2177             ctx->MutablePixels = GL_FALSE;
2178          }
2179
2180          /* update scissor region */
2181
2182          ctx->DrawBuffer->Xmin = 0;
2183          ctx->DrawBuffer->Ymin = 0;
2184          ctx->DrawBuffer->Xmax = ctx->DrawBuffer->Width-1;
2185          ctx->DrawBuffer->Ymax = ctx->DrawBuffer->Height-1;
2186          if (ctx->Scissor.Enabled) {
2187             if (ctx->Scissor.X > ctx->DrawBuffer->Xmin) {
2188                ctx->DrawBuffer->Xmin = ctx->Scissor.X;
2189             }
2190             if (ctx->Scissor.Y > ctx->DrawBuffer->Ymin) {
2191                ctx->DrawBuffer->Ymin = ctx->Scissor.Y;
2192             }
2193             if (ctx->Scissor.X + ctx->Scissor.Width - 1 < ctx->DrawBuffer->Xmax) {
2194                ctx->DrawBuffer->Xmax = ctx->Scissor.X + ctx->Scissor.Width - 1;
2195             }
2196             if (ctx->Scissor.Y + ctx->Scissor.Height - 1 < ctx->DrawBuffer->Ymax) {
2197                ctx->DrawBuffer->Ymax = ctx->Scissor.Y + ctx->Scissor.Height - 1;
2198             }
2199          }
2200
2201          /* The driver isn't managing the depth buffer.
2202           */
2203          if (ctx->Driver.AllocDepthBuffer == gl_alloc_depth_buffer)
2204          {
2205             if (ctx->Depth.Mask) {
2206                switch (ctx->Depth.Func) {
2207                case GL_LESS:
2208                   ctx->Driver.DepthTestSpan = gl_depth_test_span_less;
2209                   ctx->Driver.DepthTestPixels = gl_depth_test_pixels_less;
2210                   break;
2211                case GL_GREATER:
2212                   ctx->Driver.DepthTestSpan = gl_depth_test_span_greater;
2213                   ctx->Driver.DepthTestPixels = gl_depth_test_pixels_greater;
2214                   break;
2215                default:
2216                   ctx->Driver.DepthTestSpan = gl_depth_test_span_generic;
2217                   ctx->Driver.DepthTestPixels = gl_depth_test_pixels_generic;
2218                }
2219             }
2220             else {
2221                ctx->Driver.DepthTestSpan = gl_depth_test_span_generic;
2222                ctx->Driver.DepthTestPixels = gl_depth_test_pixels_generic;
2223             }
2224          }
2225       }
2226
2227       if (ctx->NewState & NEW_LIGHTING) {
2228          ctx->TriangleCaps &= ~(DD_TRI_LIGHT_TWOSIDE|DD_LIGHTING_CULL);
2229          if (ctx->Light.Enabled) {
2230             if (ctx->Light.Model.TwoSide)
2231                ctx->TriangleCaps |= (DD_TRI_LIGHT_TWOSIDE|DD_LIGHTING_CULL);
2232             gl_update_lighting(ctx);
2233          }
2234       }
2235    }
2236
2237    if (ctx->NewState & (NEW_POLYGON | NEW_LIGHTING)) {
2238
2239       ctx->TriangleCaps &= ~DD_TRI_CULL_FRONT_BACK;
2240
2241       if (ctx->NewState & NEW_POLYGON) {
2242          /* Setup CullBits bitmask */
2243          if (ctx->Polygon.CullFlag) {
2244             ctx->backface_sign = 1;
2245             switch(ctx->Polygon.CullFaceMode) {
2246             case GL_BACK:
2247                if(ctx->Polygon.FrontFace==GL_CCW)
2248                   ctx->backface_sign = -1;
2249                ctx->Polygon.CullBits = 1;
2250                break;
2251             case GL_FRONT:
2252                if(ctx->Polygon.FrontFace!=GL_CCW)
2253                   ctx->backface_sign = -1;
2254                ctx->Polygon.CullBits = 2;
2255                break;
2256             default:
2257             case GL_FRONT_AND_BACK:
2258                ctx->backface_sign = 0;
2259                ctx->Polygon.CullBits = 0;
2260                ctx->TriangleCaps |= DD_TRI_CULL_FRONT_BACK;
2261                break;
2262             }
2263          }
2264          else {
2265             ctx->Polygon.CullBits = 3;
2266             ctx->backface_sign = 0;
2267          }
2268
2269          /* Any Polygon offsets enabled? */
2270          ctx->TriangleCaps &= ~DD_TRI_OFFSET;
2271
2272          if (ctx->Polygon.OffsetPoint ||
2273              ctx->Polygon.OffsetLine ||
2274              ctx->Polygon.OffsetFill)
2275             ctx->TriangleCaps |= DD_TRI_OFFSET;
2276
2277          /* reset Z offsets now */
2278          ctx->PointZoffset   = 0.0;
2279          ctx->LineZoffset    = 0.0;
2280          ctx->PolygonZoffset = 0.0;
2281       }
2282    }
2283
2284    if (ctx->NewState & ~(NEW_CLIENT_STATE|
2285                          NEW_DRIVER_STATE|NEW_USER_CLIP|
2286                          NEW_POLYGON))
2287       gl_update_clipmask(ctx);
2288
2289    if (ctx->NewState & (NEW_LIGHTING|
2290                         NEW_RASTER_OPS|
2291                         NEW_TEXTURING|
2292                         NEW_TEXTURE_ENABLE|
2293                         NEW_TEXTURE_ENV|
2294                         NEW_POLYGON|
2295                         NEW_DRVSTATE0|
2296                         NEW_DRVSTATE1|
2297                         NEW_DRVSTATE2|
2298                         NEW_DRVSTATE3|
2299                         NEW_USER_CLIP))
2300    {
2301       ctx->IndirectTriangles = ctx->TriangleCaps & ~ctx->Driver.TriangleCaps;
2302       ctx->IndirectTriangles |= DD_SW_RASTERIZE;
2303
2304       if (MESA_VERBOSE&VERBOSE_CULL)
2305          gl_print_tri_caps("initial indirect tris", ctx->IndirectTriangles);
2306
2307       ctx->Driver.PointsFunc = NULL;
2308       ctx->Driver.LineFunc = NULL;
2309       ctx->Driver.TriangleFunc = NULL;
2310       ctx->Driver.QuadFunc = NULL;
2311       ctx->Driver.RectFunc = NULL;
2312       ctx->Driver.RenderVBClippedTab = NULL;
2313       ctx->Driver.RenderVBCulledTab = NULL;
2314       ctx->Driver.RenderVBRawTab = NULL;
2315
2316       /*
2317        * Here the driver sets up all the ctx->Driver function pointers to
2318        * it's specific, private functions.
2319        */
2320       ctx->Driver.UpdateState(ctx);
2321
2322       if (MESA_VERBOSE&VERBOSE_CULL)
2323          gl_print_tri_caps("indirect tris", ctx->IndirectTriangles);
2324
2325       /*
2326        * In case the driver didn't hook in an optimized point, line or
2327        * triangle function we'll now select "core/fallback" point, line
2328        * and triangle functions.
2329        */
2330       if (ctx->IndirectTriangles & DD_SW_RASTERIZE) {
2331          gl_set_point_function(ctx);
2332          gl_set_line_function(ctx);
2333          gl_set_triangle_function(ctx);
2334          gl_set_quad_function(ctx);
2335
2336          if ((ctx->IndirectTriangles &
2337               (DD_TRI_SW_RASTERIZE|DD_QUAD_SW_RASTERIZE|DD_TRI_CULL)) ==
2338              (DD_TRI_SW_RASTERIZE|DD_QUAD_SW_RASTERIZE|DD_TRI_CULL))
2339             ctx->IndirectTriangles &= ~DD_TRI_CULL;
2340       }
2341
2342       if (MESA_VERBOSE&VERBOSE_CULL)
2343          gl_print_tri_caps("indirect tris 2", ctx->IndirectTriangles);
2344
2345       gl_set_render_vb_function(ctx);
2346    }
2347
2348    /* Should only be calc'd when !need_eye_coords and not culling.
2349     */
2350    if (ctx->NewState & (NEW_MODELVIEW|NEW_PROJECTION)) {
2351       if (ctx->NewState & NEW_MODELVIEW) {
2352          gl_matrix_analyze( &ctx->ModelView );
2353          ctx->ProjectionMatrix.flags &= ~MAT_DIRTY_DEPENDENTS;
2354       }
2355
2356       if (ctx->NewState & NEW_PROJECTION) {
2357          gl_matrix_analyze( &ctx->ProjectionMatrix );
2358          ctx->ProjectionMatrix.flags &= ~MAT_DIRTY_DEPENDENTS;
2359
2360          if (ctx->Transform.AnyClip) {
2361             gl_update_userclip( ctx );
2362          }
2363       }
2364
2365       gl_calculate_model_project_matrix( ctx );
2366       ctx->ModelProjectWinMatrixUptodate = 0;
2367    }
2368
2369    /* Figure out whether we can light in object space or not.  If we
2370     * can, find the current positions of the lights in object space
2371     */
2372    if ((ctx->Enabled & (ENABLE_POINT_ATTEN | ENABLE_LIGHT | ENABLE_FOG |
2373                         ENABLE_TEXGEN0 | ENABLE_TEXGEN1)) &&
2374        (ctx->NewState & (NEW_LIGHTING |
2375                          NEW_FOG |
2376                          NEW_MODELVIEW |
2377                          NEW_PROJECTION |
2378                          NEW_TEXTURING |
2379                          NEW_RASTER_OPS |
2380                          NEW_USER_CLIP)))
2381    {
2382       GLboolean oldcoord, oldnorm;
2383
2384       oldcoord = ctx->NeedEyeCoords;
2385       oldnorm = ctx->NeedEyeNormals;
2386
2387       ctx->NeedNormals = (ctx->Light.Enabled || ctx->Texture.NeedNormals);
2388       ctx->NeedEyeCoords = ((ctx->Fog.Enabled && ctx->Hint.Fog != GL_NICEST) ||
2389                             ctx->Point.Attenuated);
2390       ctx->NeedEyeNormals = GL_FALSE;
2391
2392       if (ctx->Light.Enabled) {
2393          if (ctx->Light.Flags & LIGHT_POSITIONAL) {
2394             /* Need length for attenuation */
2395             if (!TEST_MAT_FLAGS( &ctx->ModelView, MAT_FLAGS_LENGTH_PRESERVING))
2396                ctx->NeedEyeCoords = GL_TRUE;
2397          } else if (ctx->Light.NeedVertices) {
2398             /* Need angle for spot calculations */
2399             if (!TEST_MAT_FLAGS( &ctx->ModelView, MAT_FLAGS_ANGLE_PRESERVING))
2400                ctx->NeedEyeCoords = GL_TRUE;
2401          }
2402          ctx->NeedEyeNormals = ctx->NeedEyeCoords;
2403       }
2404       if (ctx->Texture.Enabled || ctx->RenderMode==GL_FEEDBACK) {
2405          if (ctx->Texture.NeedEyeCoords) ctx->NeedEyeCoords = GL_TRUE;
2406          if (ctx->Texture.NeedNormals)
2407             ctx->NeedNormals = ctx->NeedEyeNormals = GL_TRUE;
2408       }
2409
2410       ctx->vb_proj_matrix = &ctx->ModelProjectMatrix;
2411
2412       if (ctx->NeedEyeCoords)
2413          ctx->vb_proj_matrix = &ctx->ProjectionMatrix;
2414
2415       if (ctx->Light.Enabled) {
2416          gl_update_lighting_function(ctx);
2417
2418          if ( (ctx->NewState & NEW_LIGHTING) ||
2419               ((ctx->NewState & (NEW_MODELVIEW| NEW_PROJECTION)) &&
2420                !ctx->NeedEyeCoords) ||
2421               oldcoord != ctx->NeedEyeCoords ||
2422               oldnorm != ctx->NeedEyeNormals) {
2423             gl_compute_light_positions(ctx);
2424          }
2425
2426          ctx->rescale_factor = 1.0F;
2427
2428          if (ctx->ModelView.flags & (MAT_FLAG_UNIFORM_SCALE |
2429                                      MAT_FLAG_GENERAL_SCALE |
2430                                      MAT_FLAG_GENERAL_3D |
2431                                      MAT_FLAG_GENERAL) )
2432
2433          {
2434             GLfloat *m = ctx->ModelView.inv;
2435             GLfloat f = m[2]*m[2] + m[6]*m[6] + m[10]*m[10];
2436             if (f > 1e-12 && (f-1)*(f-1) > 1e-12)
2437                ctx->rescale_factor = 1.0/GL_SQRT(f);
2438          }
2439       }
2440
2441       gl_update_normal_transform( ctx );
2442    }
2443
2444    gl_update_pipelines(ctx);
2445    ctx->NewState = 0;
2446 }