src/mesa/main/context.c

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