src/mesa/main/context.c

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