src/mesa/main/context.c

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