src/mesa/main/context.c

   1 /**
   2  * \file context.c
   3  * Mesa context/visual/framebuffer management functions.
   4  * \author Brian Paul
   5  */
   6
   7 /*
   8  * Mesa 3-D graphics library
   9  * Version:  6.5
  10  *
  11  * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
  12  *
  13  * Permission is hereby granted, free of charge, to any person obtaining a
  14  * copy of this software and associated documentation files (the "Software"),
  15  * to deal in the Software without restriction, including without limitation
  16  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  17  * and/or sell copies of the Software, and to permit persons to whom the
  18  * Software is furnished to do so, subject to the following conditions:
  19  *
  20  * The above copyright notice and this permission notice shall be included
  21  * in all copies or substantial portions of the Software.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  24  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  25  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  26  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  27  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  28  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29  */
  30
  31
  32 /**
  33  * \mainpage Mesa Main Module
  34  *
  35  * \section MainIntroduction Introduction
  36  *
  37  * The Mesa Main module consists of all the files in the main/ directory.
  38  * Among the features of this module are:
  39  * <UL>
  40  * <LI> Structures to represent most GL state </LI>
  41  * <LI> State set/get functions </LI>
  42  * <LI> Display lists </LI>
  43  * <LI> Texture unit, object and image handling </LI>
  44  * <LI> Matrix and attribute stacks </LI>
  45  * </UL>
  46  *
  47  * Other modules are responsible for API dispatch, vertex transformation,
  48  * point/line/triangle setup, rasterization, vertex array caching,
  49  * vertex/fragment programs/shaders, etc.
  50  *
  51  *
  52  * \section AboutDoxygen About Doxygen
  53  *
  54  * If you're viewing this information as Doxygen-generated HTML you'll
  55  * see the documentation index at the top of this page.
  56  *
  57  * The first line lists the Mesa source code modules.
  58  * The second line lists the indexes available for viewing the documentation
  59  * for each module.
  60  *
  61  * Selecting the <b>Main page</b> link will display a summary of the module
  62  * (this page).
  63  *
  64  * Selecting <b>Data Structures</b> will list all C structures.
  65  *
  66  * Selecting the <b>File List</b> link will list all the source files in
  67  * the module.
  68  * Selecting a filename will show a list of all functions defined in that file.
  69  *
  70  * Selecting the <b>Data Fields</b> link will display a list of all
  71  * documented structure members.
  72  *
  73  * Selecting the <b>Globals</b> link will display a list
  74  * of all functions, structures, global variables and macros in the module.
  75  *
  76  */
  77
  78
  79 #include "glheader.h"
  80 #include "imports.h"
  81 #include "accum.h"
  82 #include "attrib.h"
  83 #include "blend.h"
  84 #include "buffers.h"
  85 #include "bufferobj.h"
  86 #include "colortab.h"
  87 #include "context.h"
  88 #include "debug.h"
  89 #include "depth.h"
  90 #include "dlist.h"
  91 #include "eval.h"
  92 #include "enums.h"
  93 #include "extensions.h"
  94 #include "fbobject.h"
  95 #include "feedback.h"
  96 #include "fog.h"
  97 #include "get.h"
  98 #include "glthread.h"
  99 #include "glapioffsets.h"
 100 #include "histogram.h"
 101 #include "hint.h"
 102 #include "hash.h"
 103 #include "atifragshader.h"
 104 #include "light.h"
 105 #include "lines.h"
 106 #include "macros.h"
 107 #include "matrix.h"
 108 #include "occlude.h"
 109 #include "pixel.h"
 110 #include "points.h"
 111 #include "polygon.h"
 112 #if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
 113 #include "program.h"
 114 #endif
 115 #include "rastpos.h"
 116 #include "simple_list.h"
 117 #include "state.h"
 118 #include "stencil.h"
 119 #include "texcompress.h"
 120 #include "teximage.h"
 121 #include "texobj.h"
 122 #include "texstate.h"
 123 #include "mtypes.h"
 124 #include "varray.h"
 125 #include "version.h"
 126 #include "vtxfmt.h"
 127 #if _HAVE_FULL_GL
 128 #include "math/m_translate.h"
 129 #include "math/m_matrix.h"
 130 #include "math/m_xform.h"
 131 #include "math/mathmod.h"
 132 #endif
 133 #include "shaderobjects.h"
 134
 135 #ifdef USE_SPARC_ASM
 136 #include "sparc/sparc.h"
 137 #endif
 138
 139 #ifndef MESA_VERBOSE
 140 int MESA_VERBOSE = 0;
 141 #endif
 142
 143 #ifndef MESA_DEBUG_FLAGS
 144 int MESA_DEBUG_FLAGS = 0;
 145 #endif
 146
 147
 148 /* ubyte -> float conversion */
 149 GLfloat _mesa_ubyte_to_float_color_tab[256];
 150
 151 static void
 152 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss );
 153
 154
 155 /**********************************************************************/
 156 /** \name OpenGL SI-style interface (new in Mesa 3.5)
 157  *
 158  * \if subset
 159  * \note Most of these functions are never called in the Mesa subset.
 160  * \endif
 161  */
 162 /*@{*/
 163
 164 /**
 165  * Destroy context callback.
 166  *
 167  * \param gc context.
 168  * \return GL_TRUE on success, or GL_FALSE on failure.
 169  *
 170  * \ifnot subset
 171  * Called by window system/device driver (via __GLexports::destroyCurrent) when
 172  * the rendering context is to be destroyed.
 173  * \endif
 174  *
 175  * Frees the context data and the context structure.
 176  */
 177 GLboolean
 178 _mesa_destroyContext(__GLcontext *gc)
 179 {
 180    if (gc) {
 181       _mesa_free_context_data(gc);
 182       _mesa_free(gc);
 183    }
 184    return GL_TRUE;
 185 }
 186
 187 /**
 188  * Unbind context callback.
 189  *
 190  * \param gc context.
 191  * \return GL_TRUE on success, or GL_FALSE on failure.
 192  *
 193  * \ifnot subset
 194  * Called by window system/device driver (via __GLexports::loseCurrent)
 195  * when the rendering context is made non-current.
 196  * \endif
 197  *
 198  * No-op
 199  */
 200 GLboolean
 201 _mesa_loseCurrent(__GLcontext *gc)
 202 {
 203    /* XXX unbind context from thread */
 204    (void) gc;
 205    return GL_TRUE;
 206 }
 207
 208 /**
 209  * Bind context callback.
 210  *
 211  * \param gc context.
 212  * \return GL_TRUE on success, or GL_FALSE on failure.
 213  *
 214  * \ifnot subset
 215  * Called by window system/device driver (via __GLexports::makeCurrent)
 216  * when the rendering context is made current.
 217  * \endif
 218  *
 219  * No-op
 220  */
 221 GLboolean
 222 _mesa_makeCurrent(__GLcontext *gc)
 223 {
 224    /* XXX bind context to thread */
 225    (void) gc;
 226    return GL_TRUE;
 227 }
 228
 229 /**
 230  * Share context callback.
 231  *
 232  * \param gc context.
 233  * \param gcShare shared context.
 234  * \return GL_TRUE on success, or GL_FALSE on failure.
 235  *
 236  * \ifnot subset
 237  * Called by window system/device driver (via __GLexports::shareContext)
 238  * \endif
 239  *
 240  * Update the shared context reference count, gl_shared_state::RefCount.
 241  */
 242 GLboolean
 243 _mesa_shareContext(__GLcontext *gc, __GLcontext *gcShare)
 244 {
 245    if (gc && gcShare && gc->Shared && gcShare->Shared) {
 246       gc->Shared->RefCount--;
 247       if (gc->Shared->RefCount == 0) {
 248          free_shared_state(gc, gc->Shared);
 249       }
 250       gc->Shared = gcShare->Shared;
 251       gc->Shared->RefCount++;
 252       return GL_TRUE;
 253    }
 254    else {
 255       return GL_FALSE;
 256    }
 257 }
 258
 259
 260 #if _HAVE_FULL_GL
 261 /**
 262  * Copy context callback.
 263  */
 264 GLboolean
 265 _mesa_copyContext(__GLcontext *dst, const __GLcontext *src, GLuint mask)
 266 {
 267    if (dst && src) {
 268       _mesa_copy_context( src, dst, mask );
 269       return GL_TRUE;
 270    }
 271    else {
 272       return GL_FALSE;
 273    }
 274 }
 275 #endif
 276
 277 /** No-op */
 278 GLboolean
 279 _mesa_forceCurrent(__GLcontext *gc)
 280 {
 281    (void) gc;
 282    return GL_TRUE;
 283 }
 284
 285 /**
 286  * Windows/buffer resizing notification callback.
 287  *
 288  * \param gc GL context.
 289  * \return GL_TRUE on success, or GL_FALSE on failure.
 290  */
 291 GLboolean
 292 _mesa_notifyResize(__GLcontext *gc)
 293 {
 294    GLint x, y;
 295    GLuint width, height;
 296    __GLdrawablePrivate *d = gc->imports.getDrawablePrivate(gc);
 297    if (!d || !d->getDrawableSize)
 298       return GL_FALSE;
 299    d->getDrawableSize( d, &x, &y, &width, &height );
 300    /* update viewport, resize software buffers, etc. */
 301    return GL_TRUE;
 302 }
 303
 304 /**
 305  * Window/buffer destruction notification callback.
 306  *
 307  * \param gc GL context.
 308  *
 309  * Called when the context's window/buffer is going to be destroyed.
 310  *
 311  * No-op
 312  */
 313 void
 314 _mesa_notifyDestroy(__GLcontext *gc)
 315 {
 316    /* Unbind from it. */
 317    (void) gc;
 318 }
 319
 320 /**
 321  * Swap buffers notification callback.
 322  *
 323  * \param gc GL context.
 324  *
 325  * Called by window system just before swapping buffers.
 326  * We have to finish any pending rendering.
 327  */
 328 void
 329 _mesa_notifySwapBuffers(__GLcontext *gc)
 330 {
 331    FLUSH_VERTICES( gc, 0 );
 332 }
 333
 334 /** No-op */
 335 struct __GLdispatchStateRec *
 336 _mesa_dispatchExec(__GLcontext *gc)
 337 {
 338    (void) gc;
 339    return NULL;
 340 }
 341
 342 /** No-op */
 343 void
 344 _mesa_beginDispatchOverride(__GLcontext *gc)
 345 {
 346    (void) gc;
 347 }
 348
 349 /** No-op */
 350 void
 351 _mesa_endDispatchOverride(__GLcontext *gc)
 352 {
 353    (void) gc;
 354 }
 355
 356 /**
 357  * \ifnot subset
 358  * Setup the exports.
 359  *
 360  * The window system will call these functions when it needs Mesa to do
 361  * something.
 362  *
 363  * \note Device drivers should override these functions!  For example,
 364  * the Xlib driver should plug in the XMesa*-style functions into this
 365  * structure.  The XMesa-style functions should then call the _mesa_*
 366  * version of these functions.  This is an approximation to OO design
 367  * (inheritance and virtual functions).
 368  * \endif
 369  *
 370  * \if subset
 371  * No-op.
 372  *
 373  * \endif
 374  */
 375 static void
 376 _mesa_init_default_exports(__GLexports *exports)
 377 {
 378 #if _HAVE_FULL_GL
 379     exports->destroyContext = _mesa_destroyContext;
 380     exports->loseCurrent = _mesa_loseCurrent;
 381     exports->makeCurrent = _mesa_makeCurrent;
 382     exports->shareContext = _mesa_shareContext;
 383     exports->copyContext = _mesa_copyContext;
 384     exports->forceCurrent = _mesa_forceCurrent;
 385     exports->notifyResize = _mesa_notifyResize;
 386     exports->notifyDestroy = _mesa_notifyDestroy;
 387     exports->notifySwapBuffers = _mesa_notifySwapBuffers;
 388     exports->dispatchExec = _mesa_dispatchExec;
 389     exports->beginDispatchOverride = _mesa_beginDispatchOverride;
 390     exports->endDispatchOverride = _mesa_endDispatchOverride;
 391 #else
 392     (void) exports;
 393 #endif
 394 }
 395
 396 /**
 397  * Exported OpenGL SI interface.
 398  */
 399 __GLcontext *
 400 __glCoreCreateContext(__GLimports *imports, __GLcontextModes *modes)
 401 {
 402     GLcontext *ctx;
 403
 404     ctx = (GLcontext *) (*imports->calloc)(NULL, 1, sizeof(GLcontext));
 405     if (ctx == NULL) {
 406         return NULL;
 407     }
 408
 409     /* XXX doesn't work at this time */
 410     _mesa_initialize_context(ctx, modes, NULL, NULL, NULL);
 411     ctx->imports = *imports;
 412
 413     return ctx;
 414 }
 415
 416 /**
 417  * Exported OpenGL SI interface.
 418  */
 419 void
 420 __glCoreNopDispatch(void)
 421 {
 422 #if 0
 423    /* SI */
 424    __gl_dispatch = __glNopDispatchState;
 425 #else
 426    /* Mesa */
 427    _glapi_set_dispatch(NULL);
 428 #endif
 429 }
 430
 431 /*@}*/
 432
 433
 434 /**********************************************************************/
 435 /** \name GL Visual allocation/destruction                            */
 436 /**********************************************************************/
 437 /*@{*/
 438
 439 /**
 440  * Allocates a GLvisual structure and initializes it via
 441  * _mesa_initialize_visual().
 442  *
 443  * \param rgbFlag GL_TRUE for RGB(A) mode, GL_FALSE for Color Index mode.
 444  * \param dbFlag double buffering
 445  * \param stereoFlag stereo buffer
 446  * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
 447  * is acceptable but the actual depth type will be GLushort or GLuint as
 448  * needed.
 449  * \param stencilBits requested minimum bits per stencil buffer value
 450  * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.
 451  * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
 452  * \param redBits number of bits per color component in frame buffer for RGB(A)
 453  * mode.  We always use 8 in core Mesa though.
 454  * \param greenBits same as above.
 455  * \param blueBits same as above.
 456  * \param alphaBits same as above.
 457  * \param numSamples not really used.
 458  *
 459  * \return pointer to new GLvisual or NULL if requested parameters can't be
 460  * met.
 461  *
 462  * \note Need to add params for level and numAuxBuffers (at least)
 463  */
 464 GLvisual *
 465 _mesa_create_visual( GLboolean rgbFlag,
 466                      GLboolean dbFlag,
 467                      GLboolean stereoFlag,
 468                      GLint redBits,
 469                      GLint greenBits,
 470                      GLint blueBits,
 471                      GLint alphaBits,
 472                      GLint indexBits,
 473                      GLint depthBits,
 474                      GLint stencilBits,
 475                      GLint accumRedBits,
 476                      GLint accumGreenBits,
 477                      GLint accumBlueBits,
 478                      GLint accumAlphaBits,
 479                      GLint numSamples )
 480 {
 481    GLvisual *vis = (GLvisual *) CALLOC( sizeof(GLvisual) );
 482    if (vis) {
 483       if (!_mesa_initialize_visual(vis, rgbFlag, dbFlag, stereoFlag,
 484                                    redBits, greenBits, blueBits, alphaBits,
 485                                    indexBits, depthBits, stencilBits,
 486                                    accumRedBits, accumGreenBits,
 487                                    accumBlueBits, accumAlphaBits,
 488                                    numSamples)) {
 489          FREE(vis);
 490          return NULL;
 491       }
 492    }
 493    return vis;
 494 }
 495
 496 /**
 497  * Makes some sanity checks and fills in the fields of the
 498  * GLvisual object with the given parameters.  If the caller needs
 499  * to set additional fields, he should just probably init the whole GLvisual
 500  * object himself.
 501  * \return GL_TRUE on success, or GL_FALSE on failure.
 502  *
 503  * \sa _mesa_create_visual() above for the parameter description.
 504  */
 505 GLboolean
 506 _mesa_initialize_visual( GLvisual *vis,
 507                          GLboolean rgbFlag,
 508                          GLboolean dbFlag,
 509                          GLboolean stereoFlag,
 510                          GLint redBits,
 511                          GLint greenBits,
 512                          GLint blueBits,
 513                          GLint alphaBits,
 514                          GLint indexBits,
 515                          GLint depthBits,
 516                          GLint stencilBits,
 517                          GLint accumRedBits,
 518                          GLint accumGreenBits,
 519                          GLint accumBlueBits,
 520                          GLint accumAlphaBits,
 521                          GLint numSamples )
 522 {
 523    assert(vis);
 524
 525    if (depthBits < 0 || depthBits > 32) {
 526       return GL_FALSE;
 527    }
 528    if (stencilBits < 0 || stencilBits > STENCIL_BITS) {
 529       return GL_FALSE;
 530    }
 531    assert(accumRedBits >= 0);
 532    assert(accumGreenBits >= 0);
 533    assert(accumBlueBits >= 0);
 534    assert(accumAlphaBits >= 0);
 535
 536    vis->rgbMode          = rgbFlag;
 537    vis->doubleBufferMode = dbFlag;
 538    vis->stereoMode       = stereoFlag;
 539
 540    vis->redBits          = redBits;
 541    vis->greenBits        = greenBits;
 542    vis->blueBits         = blueBits;
 543    vis->alphaBits        = alphaBits;
 544    vis->rgbBits          = redBits + greenBits + blueBits;
 545
 546    vis->indexBits      = indexBits;
 547    vis->depthBits      = depthBits;
 548    vis->stencilBits    = stencilBits;
 549
 550    vis->accumRedBits   = accumRedBits;
 551    vis->accumGreenBits = accumGreenBits;
 552    vis->accumBlueBits  = accumBlueBits;
 553    vis->accumAlphaBits = accumAlphaBits;
 554
 555    vis->haveAccumBuffer   = accumRedBits > 0;
 556    vis->haveDepthBuffer   = depthBits > 0;
 557    vis->haveStencilBuffer = stencilBits > 0;
 558
 559    vis->numAuxBuffers = 0;
 560    vis->level = 0;
 561    vis->pixmapMode = 0;
 562    vis->sampleBuffers = numSamples > 0 ? 1 : 0;
 563    vis->samples = numSamples;
 564
 565    return GL_TRUE;
 566 }
 567
 568
 569 /**
 570  * Destroy a visual and free its memory.
 571  *
 572  * \param vis visual.
 573  *
 574  * Frees the visual structure.
 575  */
 576 void
 577 _mesa_destroy_visual( GLvisual *vis )
 578 {
 579    FREE(vis);
 580 }
 581
 582 /*@}*/
 583
 584
 585 /**********************************************************************/
 586 /** \name Context allocation, initialization, destroying
 587  *
 588  * The purpose of the most initialization functions here is to provide the
 589  * default state values according to the OpenGL specification.
 590  */
 591 /**********************************************************************/
 592 /*@{*/
 593
 594 /**
 595  * One-time initialization mutex lock.
 596  *
 597  * \sa Used by one_time_init().
 598  */
 599 _glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
 600
 601 /**
 602  * Calls all the various one-time-init functions in Mesa.
 603  *
 604  * While holding a global mutex lock, calls several initialization functions,
 605  * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
 606  * defined.
 607  *
 608  * \sa _mesa_init_lists(), _math_init().
 609  */
 610 static void
 611 one_time_init( GLcontext *ctx )
 612 {
 613    static GLboolean alreadyCalled = GL_FALSE;
 614    (void) ctx;
 615    _glthread_LOCK_MUTEX(OneTimeLock);
 616    if (!alreadyCalled) {
 617       GLuint i;
 618
 619       /* do some implementation tests */
 620       assert( sizeof(GLbyte) == 1 );
 621       assert( sizeof(GLubyte) == 1 );
 622       assert( sizeof(GLshort) == 2 );
 623       assert( sizeof(GLushort) == 2 );
 624       assert( sizeof(GLint) == 4 );
 625       assert( sizeof(GLuint) == 4 );
 626
 627       _mesa_init_lists();
 628
 629 #if _HAVE_FULL_GL
 630       _math_init();
 631
 632       for (i = 0; i < 256; i++) {
 633          _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
 634       }
 635 #endif
 636
 637 #ifdef USE_SPARC_ASM
 638       _mesa_init_sparc_glapi_relocs();
 639 #endif
 640       if (_mesa_getenv("MESA_DEBUG")) {
 641          _glapi_noop_enable_warnings(GL_TRUE);
 642          _glapi_set_warning_func( (_glapi_warning_func) _mesa_warning );
 643       }
 644       else {
 645          _glapi_noop_enable_warnings(GL_FALSE);
 646       }
 647
 648 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
 649       _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
 650                   MESA_VERSION_STRING, __DATE__, __TIME__);
 651 #endif
 652
 653       alreadyCalled = GL_TRUE;
 654    }
 655    _glthread_UNLOCK_MUTEX(OneTimeLock);
 656 }
 657
 658
 659 /**
 660  * Allocate and initialize a shared context state structure.
 661  * Initializes the display list, texture objects and vertex programs hash
 662  * tables, allocates the texture objects. If it runs out of memory, frees
 663  * everything already allocated before returning NULL.
 664  *
 665  * \return pointer to a gl_shared_state structure on success, or NULL on
 666  * failure.
 667  */
 668 static GLboolean
 669 alloc_shared_state( GLcontext *ctx )
 670 {
 671    struct gl_shared_state *ss = CALLOC_STRUCT(gl_shared_state);
 672    if (!ss)
 673       return GL_FALSE;
 674
 675    ctx->Shared = ss;
 676
 677    _glthread_INIT_MUTEX(ss->Mutex);
 678
 679    ss->DisplayList = _mesa_NewHashTable();
 680    ss->TexObjects = _mesa_NewHashTable();
 681 #if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
 682    ss->Programs = _mesa_NewHashTable();
 683 #endif
 684
 685 #if FEATURE_ARB_vertex_program
 686    ss->DefaultVertexProgram = ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
 687    if (!ss->DefaultVertexProgram)
 688       goto cleanup;
 689 #endif
 690 #if FEATURE_ARB_fragment_program
 691    ss->DefaultFragmentProgram = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
 692    if (!ss->DefaultFragmentProgram)
 693       goto cleanup;
 694 #endif
 695 #if FEATURE_ATI_fragment_shader
 696    ss->ATIShaders = _mesa_NewHashTable();
 697    ss->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0);
 698    if (!ss->DefaultFragmentShader)
 699       goto cleanup;
 700 #endif
 701
 702    ss->BufferObjects = _mesa_NewHashTable();
 703
 704    ss->GL2Objects = _mesa_NewHashTable ();
 705
 706    ss->Default1D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D);
 707    if (!ss->Default1D)
 708       goto cleanup;
 709
 710    ss->Default2D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D);
 711    if (!ss->Default2D)
 712       goto cleanup;
 713
 714    ss->Default3D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_3D);
 715    if (!ss->Default3D)
 716       goto cleanup;
 717
 718    ss->DefaultCubeMap = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_CUBE_MAP_ARB);
 719    if (!ss->DefaultCubeMap)
 720       goto cleanup;
 721
 722    ss->DefaultRect = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_RECTANGLE_NV);
 723    if (!ss->DefaultRect)
 724       goto cleanup;
 725
 726    /* Effectively bind the default textures to all texture units */
 727    ss->Default1D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 728    ss->Default2D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 729    ss->Default3D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 730    ss->DefaultCubeMap->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 731    ss->DefaultRect->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 732
 733 #if FEATURE_EXT_framebuffer_object
 734    ss->FrameBuffers = _mesa_NewHashTable();
 735    if (!ss->FrameBuffers)
 736       goto cleanup;
 737    ss->RenderBuffers = _mesa_NewHashTable();
 738    if (!ss->RenderBuffers)
 739       goto cleanup;
 740 #endif
 741
 742
 743    return GL_TRUE;
 744
 745  cleanup:
 746    /* Ran out of memory at some point.  Free everything and return NULL */
 747    if (ss->DisplayList)
 748       _mesa_DeleteHashTable(ss->DisplayList);
 749    if (ss->TexObjects)
 750       _mesa_DeleteHashTable(ss->TexObjects);
 751 #if FEATURE_NV_vertex_program
 752    if (ss->Programs)
 753       _mesa_DeleteHashTable(ss->Programs);
 754 #endif
 755 #if FEATURE_ARB_vertex_program
 756    if (ss->DefaultVertexProgram)
 757       ctx->Driver.DeleteProgram(ctx, ss->DefaultVertexProgram);
 758 #endif
 759 #if FEATURE_ARB_fragment_program
 760    if (ss->DefaultFragmentProgram)
 761       ctx->Driver.DeleteProgram(ctx, ss->DefaultFragmentProgram);
 762 #endif
 763 #if FEATURE_ATI_fragment_shader
 764    if (ss->DefaultFragmentShader)
 765       _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
 766 #endif
 767 #if FEATURE_ARB_vertex_buffer_object
 768    if (ss->BufferObjects)
 769       _mesa_DeleteHashTable(ss->BufferObjects);
 770 #endif
 771
 772    if (ss->GL2Objects)
 773       _mesa_DeleteHashTable (ss->GL2Objects);
 774
 775 #if FEATURE_EXT_framebuffer_object
 776    if (ss->FrameBuffers)
 777       _mesa_DeleteHashTable(ss->FrameBuffers);
 778    if (ss->RenderBuffers)
 779       _mesa_DeleteHashTable(ss->RenderBuffers);
 780 #endif
 781
 782    if (ss->Default1D)
 783       (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D);
 784    if (ss->Default2D)
 785       (*ctx->Driver.DeleteTexture)(ctx, ss->Default2D);
 786    if (ss->Default3D)
 787       (*ctx->Driver.DeleteTexture)(ctx, ss->Default3D);
 788    if (ss->DefaultCubeMap)
 789       (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap);
 790    if (ss->DefaultRect)
 791       (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect);
 792    if (ss)
 793       _mesa_free(ss);
 794    return GL_FALSE;
 795 }
 796
 797 /**
 798  * Deallocate a shared state context and all children structures.
 799  *
 800  * \param ctx GL context.
 801  * \param ss shared state pointer.
 802  *
 803  * Frees the display lists, the texture objects (calling the driver texture
 804  * deletion callback to free its private data) and the vertex programs, as well
 805  * as their hash tables.
 806  *
 807  * \sa alloc_shared_state().
 808  */
 809 static void
 810 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
 811 {
 812    /* Free display lists */
 813    while (1) {
 814       GLuint list = _mesa_HashFirstEntry(ss->DisplayList);
 815       if (list) {
 816          _mesa_destroy_list(ctx, list);
 817       }
 818       else {
 819          break;
 820       }
 821    }
 822    _mesa_DeleteHashTable(ss->DisplayList);
 823
 824    /* Free texture objects */
 825    ASSERT(ctx->Driver.DeleteTexture);
 826    /* the default textures */
 827    (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D);
 828    (*ctx->Driver.DeleteTexture)(ctx, ss->Default2D);
 829    (*ctx->Driver.DeleteTexture)(ctx, ss->Default3D);
 830    (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap);
 831    (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect);
 832    /* all other textures */
 833    while (1) {
 834       GLuint texName = _mesa_HashFirstEntry(ss->TexObjects);
 835       if (texName) {
 836          struct gl_texture_object *texObj = (struct gl_texture_object *)
 837             _mesa_HashLookup(ss->TexObjects, texName);
 838          ASSERT(texObj);
 839          (*ctx->Driver.DeleteTexture)(ctx, texObj);
 840          _mesa_HashRemove(ss->TexObjects, texName);
 841       }
 842       else {
 843          break;
 844       }
 845    }
 846    _mesa_DeleteHashTable(ss->TexObjects);
 847
 848 #if FEATURE_NV_vertex_program
 849    /* Free vertex programs */
 850    while (1) {
 851       GLuint prog = _mesa_HashFirstEntry(ss->Programs);
 852       if (prog) {
 853          struct program *p = (struct program *) _mesa_HashLookup(ss->Programs,
 854                                                                  prog);
 855          ASSERT(p);
 856          ctx->Driver.DeleteProgram(ctx, p);
 857          _mesa_HashRemove(ss->Programs, prog);
 858       }
 859       else {
 860          break;
 861       }
 862    }
 863    _mesa_DeleteHashTable(ss->Programs);
 864 #endif
 865 #if FEATURE_ARB_vertex_program
 866    _mesa_delete_program(ctx, ss->DefaultVertexProgram);
 867 #endif
 868 #if FEATURE_ARB_fragment_program
 869    _mesa_delete_program(ctx, ss->DefaultFragmentProgram);
 870 #endif
 871 #if FEATURE_ATI_fragment_shader
 872    _mesa_free(ss->DefaultFragmentShader);
 873 #endif
 874
 875 #if FEATURE_ARB_vertex_buffer_object
 876    _mesa_DeleteHashTable(ss->BufferObjects);
 877 #endif
 878
 879    _mesa_DeleteHashTable (ss->GL2Objects);
 880
 881 #if FEATURE_EXT_framebuffer_object
 882    _mesa_DeleteHashTable(ss->FrameBuffers);
 883    _mesa_DeleteHashTable(ss->RenderBuffers);
 884 #endif
 885
 886    _glthread_DESTROY_MUTEX(ss->Mutex);
 887
 888    FREE(ss);
 889 }
 890
 891
 892 /**
 893  * Initialize fields of gl_current_attrib (aka ctx->Current.*)
 894  */
 895 static void
 896 _mesa_init_current( GLcontext *ctx )
 897 {
 898    GLuint i;
 899
 900    /* Current group */
 901    for (i = 0; i < VERT_ATTRIB_MAX; i++) {
 902       ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
 903    }
 904    /* special cases: */
 905    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 1.0 );
 906    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
 907    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
 908    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
 909    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_FOG], 0.0, 0.0, 0.0, 0.0 );
 910
 911    ctx->Current.Index = 1;
 912    ctx->Current.EdgeFlag = GL_TRUE;
 913 }
 914
 915
 916 /**
 917  * Init vertex/fragment program native limits from logical limits.
 918  */
 919 static void
 920 init_natives(struct gl_program_constants *prog)
 921 {
 922    prog->MaxNativeInstructions = prog->MaxInstructions;
 923    prog->MaxNativeAluInstructions = prog->MaxAluInstructions;
 924    prog->MaxNativeTexInstructions = prog->MaxTexInstructions;
 925    prog->MaxNativeTexIndirections = prog->MaxTexIndirections;
 926    prog->MaxNativeAttribs = prog->MaxAttribs;
 927    prog->MaxNativeTemps = prog->MaxTemps;
 928    prog->MaxNativeAddressRegs = prog->MaxAddressRegs;
 929    prog->MaxNativeParameters = prog->MaxParameters;
 930 }
 931
 932
 933 /**
 934  * Initialize fields of gl_constants (aka ctx->Const.*).
 935  * Use defaults from config.h.  The device drivers will often override
 936  * some of these values (such as number of texture units).
 937  */
 938 static void
 939 _mesa_init_constants( GLcontext *ctx )
 940 {
 941    assert(ctx);
 942
 943    assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
 944    assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
 945
 946    /* Constants, may be overriden (usually only reduced) by device drivers */
 947    ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
 948    ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
 949    ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
 950    ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
 951    ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
 952    ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
 953    ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 954    ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
 955    ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
 956    ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
 957    ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
 958    ctx->Const.MinPointSize = MIN_POINT_SIZE;
 959    ctx->Const.MaxPointSize = MAX_POINT_SIZE;
 960    ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
 961    ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
 962    ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
 963    ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
 964    ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
 965    ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
 966    ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
 967    ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
 968    ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
 969    ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
 970    ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
 971    ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
 972    ctx->Const.MaxLights = MAX_LIGHTS;
 973    ctx->Const.MaxShininess = 128.0;
 974    ctx->Const.MaxSpotExponent = 128.0;
 975    ctx->Const.MaxViewportWidth = MAX_WIDTH;
 976    ctx->Const.MaxViewportHeight = MAX_HEIGHT;
 977 #if FEATURE_ARB_vertex_program
 978    ctx->Const.VertexProgram.MaxInstructions = MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS;
 979    ctx->Const.VertexProgram.MaxAluInstructions = 0;
 980    ctx->Const.VertexProgram.MaxTexInstructions = 0;
 981    ctx->Const.VertexProgram.MaxTexIndirections = 0;
 982    ctx->Const.VertexProgram.MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
 983    ctx->Const.VertexProgram.MaxTemps = MAX_NV_VERTEX_PROGRAM_TEMPS;
 984    ctx->Const.VertexProgram.MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
 985    ctx->Const.VertexProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
 986    ctx->Const.VertexProgram.MaxEnvParams = MAX_NV_VERTEX_PROGRAM_PARAMS;
 987    ctx->Const.VertexProgram.MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
 988    init_natives(&ctx->Const.VertexProgram);
 989 #endif
 990 #if FEATURE_ARB_fragment_program
 991    ctx->Const.FragmentProgram.MaxInstructions = MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS;
 992    ctx->Const.FragmentProgram.MaxAluInstructions = MAX_FRAGMENT_PROGRAM_ALU_INSTRUCTIONS;
 993    ctx->Const.FragmentProgram.MaxTexInstructions = MAX_FRAGMENT_PROGRAM_TEX_INSTRUCTIONS;
 994    ctx->Const.FragmentProgram.MaxTexIndirections = MAX_FRAGMENT_PROGRAM_TEX_INDIRECTIONS;
 995    ctx->Const.FragmentProgram.MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
 996    ctx->Const.FragmentProgram.MaxTemps = MAX_NV_FRAGMENT_PROGRAM_TEMPS;
 997    ctx->Const.FragmentProgram.MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
 998    ctx->Const.FragmentProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
 999    ctx->Const.FragmentProgram.MaxEnvParams = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
1000    ctx->Const.FragmentProgram.MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
1001    init_natives(&ctx->Const.FragmentProgram);
1002 #endif
1003    ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
1004    ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
1005
1006    /* If we're running in the X server, do bounds checking to prevent
1007     * segfaults and server crashes!
1008     */
1009 #if defined(XFree86LOADER) && defined(IN_MODULE)
1010    ctx->Const.CheckArrayBounds = GL_TRUE;
1011 #else
1012    ctx->Const.CheckArrayBounds = GL_FALSE;
1013 #endif
1014
1015    /* GL_ARB_draw_buffers */
1016    ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
1017
1018    /* GL_OES_read_format */
1019    ctx->Const.ColorReadFormat = GL_RGBA;
1020    ctx->Const.ColorReadType = GL_UNSIGNED_BYTE;
1021
1022 #if FEATURE_EXT_framebuffer_object
1023    ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
1024    ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
1025 #endif
1026
1027    /* sanity checks */
1028    ASSERT(ctx->Const.MaxTextureUnits == MAX2(ctx->Const.MaxTextureImageUnits, ctx->Const.MaxTextureCoordUnits));
1029    ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
1030    ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
1031 }
1032
1033
1034 /**
1035  * Initialize the attribute groups in a GL context.
1036  *
1037  * \param ctx GL context.
1038  *
1039  * Initializes all the attributes, calling the respective <tt>init*</tt>
1040  * functions for the more complex data structures.
1041  */
1042 static GLboolean
1043 init_attrib_groups( GLcontext *ctx )
1044 {
1045    assert(ctx);
1046
1047    /* Constants */
1048    _mesa_init_constants( ctx );
1049
1050    /* Extensions */
1051    _mesa_init_extensions( ctx );
1052
1053    /* Attribute Groups */
1054    _mesa_init_accum( ctx );
1055    _mesa_init_attrib( ctx );
1056    _mesa_init_buffer_objects( ctx );
1057    _mesa_init_color( ctx );
1058    _mesa_init_colortables( ctx );
1059    _mesa_init_current( ctx );
1060    _mesa_init_depth( ctx );
1061    _mesa_init_debug( ctx );
1062    _mesa_init_display_list( ctx );
1063    _mesa_init_eval( ctx );
1064    _mesa_init_feedback( ctx );
1065    _mesa_init_fog( ctx );
1066    _mesa_init_histogram( ctx );
1067    _mesa_init_hint( ctx );
1068    _mesa_init_line( ctx );
1069    _mesa_init_lighting( ctx );
1070    _mesa_init_matrix( ctx );
1071    _mesa_init_multisample( ctx );
1072    _mesa_init_pixel( ctx );
1073    _mesa_init_point( ctx );
1074    _mesa_init_polygon( ctx );
1075    _mesa_init_program( ctx );
1076    _mesa_init_query( ctx );
1077    _mesa_init_rastpos( ctx );
1078    _mesa_init_scissor( ctx );
1079    _mesa_init_shaderobjects (ctx);
1080    _mesa_init_stencil( ctx );
1081    _mesa_init_transform( ctx );
1082    _mesa_init_varray( ctx );
1083    _mesa_init_viewport( ctx );
1084
1085    if (!_mesa_init_texture( ctx ))
1086       return GL_FALSE;
1087
1088    _mesa_init_texture_s3tc( ctx );
1089    _mesa_init_texture_fxt1( ctx );
1090
1091    /* Miscellaneous */
1092    ctx->NewState = _NEW_ALL;
1093    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1094    ctx->_Facing = 0;
1095
1096    return GL_TRUE;
1097 }
1098
1099
1100 /**
1101  * This is the default function we plug into all dispatch table slots
1102  * This helps prevents a segfault when someone calls a GL function without
1103  * first checking if the extension's supported.
1104  */
1105 static int
1106 generic_nop(void)
1107 {
1108    _mesa_problem(NULL, "User called no-op dispatch function (an unsupported extension function?)");
1109    return 0;
1110 }
1111
1112
1113 /**
1114  * Allocate and initialize a new dispatch table.
1115  */
1116 static struct _glapi_table *
1117 alloc_dispatch_table(void)
1118 {
1119    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1120     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
1121     * Mesa we do this to accomodate different versions of libGL and various
1122     * DRI drivers.
1123     */
1124    GLint numEntries = MAX2(_glapi_get_dispatch_table_size(),
1125                            sizeof(struct _glapi_table) / sizeof(_glapi_proc));
1126    struct _glapi_table *table =
1127       (struct _glapi_table *) _mesa_malloc(numEntries * sizeof(_glapi_proc));
1128    if (table) {
1129       _glapi_proc *entry = (_glapi_proc *) table;
1130       GLint i;
1131       for (i = 0; i < numEntries; i++) {
1132          entry[i] = (_glapi_proc) generic_nop;
1133       }
1134    }
1135    return table;
1136 }
1137
1138
1139 /**
1140  * Initialize a GLcontext struct (rendering context).
1141  *
1142  * This includes allocating all the other structs and arrays which hang off of
1143  * the context by pointers.
1144  * Note that the driver needs to pass in its dd_function_table here since
1145  * we need to at least call driverFunctions->NewTextureObject to create the
1146  * default texture objects.
1147  *
1148  * Called by _mesa_create_context().
1149  *
1150  * Performs the imports and exports callback tables initialization, and
1151  * miscellaneous one-time initializations. If no shared context is supplied one
1152  * is allocated, and increase its reference count.  Setups the GL API dispatch
1153  * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
1154  * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1155  * for debug flags.
1156  *
1157  * \param ctx the context to initialize
1158  * \param visual describes the visual attributes for this context
1159  * \param share_list points to context to share textures, display lists,
1160  *        etc with, or NULL
1161  * \param driverFunctions table of device driver functions for this context
1162  *        to use
1163  * \param driverContext pointer to driver-specific context data
1164  */
1165 GLboolean
1166 _mesa_initialize_context( GLcontext *ctx,
1167                           const GLvisual *visual,
1168                           GLcontext *share_list,
1169                           const struct dd_function_table *driverFunctions,
1170                           void *driverContext )
1171 {
1172    ASSERT(driverContext);
1173    assert(driverFunctions->NewTextureObject);
1174    assert(driverFunctions->FreeTexImageData);
1175
1176    /* If the driver wants core Mesa to use special imports, it'll have to
1177     * override these defaults.
1178     */
1179    _mesa_init_default_imports( &(ctx->imports), driverContext );
1180
1181    /* initialize the exports (Mesa functions called by the window system) */
1182    _mesa_init_default_exports( &(ctx->exports) );
1183
1184    /* misc one-time initializations */
1185    one_time_init(ctx);
1186
1187    ctx->Visual = *visual;
1188    ctx->DrawBuffer = NULL;
1189    ctx->ReadBuffer = NULL;
1190    ctx->WinSysDrawBuffer = NULL;
1191    ctx->WinSysReadBuffer = NULL;
1192
1193    /* Plug in driver functions and context pointer here.
1194     * This is important because when we call alloc_shared_state() below
1195     * we'll call ctx->Driver.NewTextureObject() to create the default
1196     * textures.
1197     */
1198    ctx->Driver = *driverFunctions;
1199    ctx->DriverCtx = driverContext;
1200
1201    if (share_list) {
1202       /* share state with another context */
1203       ctx->Shared = share_list->Shared;
1204    }
1205    else {
1206       /* allocate new, unshared state */
1207       if (!alloc_shared_state( ctx )) {
1208          return GL_FALSE;
1209       }
1210    }
1211    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1212    ctx->Shared->RefCount++;
1213    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1214
1215    if (!init_attrib_groups( ctx )) {
1216       free_shared_state(ctx, ctx->Shared);
1217       return GL_FALSE;
1218    }
1219
1220    /* setup the API dispatch tables */
1221    ctx->Exec = alloc_dispatch_table();
1222    ctx->Save = alloc_dispatch_table();
1223    if (!ctx->Exec || !ctx->Save) {
1224       free_shared_state(ctx, ctx->Shared);
1225       if (ctx->Exec)
1226          _mesa_free(ctx->Exec);
1227    }
1228    _mesa_init_exec_table(ctx->Exec);
1229    ctx->CurrentDispatch = ctx->Exec;
1230 #if _HAVE_FULL_GL
1231    _mesa_init_dlist_table(ctx->Save);
1232    _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
1233    /* Neutral tnl module stuff */
1234    _mesa_init_exec_vtxfmt( ctx );
1235    ctx->TnlModule.Current = NULL;
1236    ctx->TnlModule.SwapCount = 0;
1237 #endif
1238
1239    ctx->_MaintainTexEnvProgram = (_mesa_getenv("MESA_TEX_PROG") != NULL);
1240    ctx->_UseTexEnvProgram = ctx->_MaintainTexEnvProgram;
1241
1242    ctx->_MaintainTnlProgram = (_mesa_getenv("MESA_TNL_PROG") != NULL);
1243    if (ctx->_MaintainTnlProgram)
1244       ctx->_MaintainTexEnvProgram = 1; /* this is required... */
1245
1246    ctx->FirstTimeCurrent = GL_TRUE;
1247
1248    return GL_TRUE;
1249 }
1250
1251
1252 /**
1253  * Allocate and initialize a GLcontext structure.
1254  * Note that the driver needs to pass in its dd_function_table here since
1255  * we need to at least call driverFunctions->NewTextureObject to initialize
1256  * the rendering context.
1257  *
1258  * \param visual a GLvisual pointer (we copy the struct contents)
1259  * \param share_list another context to share display lists with or NULL
1260  * \param driverFunctions points to the dd_function_table into which the
1261  *        driver has plugged in all its special functions.
1262  * \param driverCtx points to the device driver's private context state
1263  *
1264  * \return pointer to a new __GLcontextRec or NULL if error.
1265  */
1266 GLcontext *
1267 _mesa_create_context( const GLvisual *visual,
1268                       GLcontext *share_list,
1269                       const struct dd_function_table *driverFunctions,
1270                       void *driverContext )
1271
1272 {
1273    GLcontext *ctx;
1274
1275    ASSERT(visual);
1276    ASSERT(driverContext);
1277
1278    ctx = (GLcontext *) _mesa_calloc(sizeof(GLcontext));
1279    if (!ctx)
1280       return NULL;
1281
1282    if (_mesa_initialize_context(ctx, visual, share_list,
1283                                 driverFunctions, driverContext)) {
1284       return ctx;
1285    }
1286    else {
1287       _mesa_free(ctx);
1288       return NULL;
1289    }
1290 }
1291
1292
1293 /**
1294  * Free the data associated with the given context.
1295  *
1296  * But doesn't free the GLcontext struct itself.
1297  *
1298  * \sa _mesa_initialize_context() and init_attrib_groups().
1299  */
1300 void
1301 _mesa_free_context_data( GLcontext *ctx )
1302 {
1303    /* if we're destroying the current context, unbind it first */
1304    if (ctx == _mesa_get_current_context()) {
1305       _mesa_make_current(NULL, NULL, NULL);
1306    }
1307
1308    _mesa_free_lighting_data( ctx );
1309    _mesa_free_eval_data( ctx );
1310    _mesa_free_texture_data( ctx );
1311    _mesa_free_matrix_data( ctx );
1312    _mesa_free_viewport_data( ctx );
1313    _mesa_free_colortables_data( ctx );
1314    _mesa_free_program_data(ctx);
1315    _mesa_free_query_data(ctx);
1316
1317 #if FEATURE_ARB_vertex_buffer_object
1318    _mesa_delete_buffer_object(ctx, ctx->Array.NullBufferObj);
1319 #endif
1320
1321    /* free dispatch tables */
1322    _mesa_free(ctx->Exec);
1323    _mesa_free(ctx->Save);
1324
1325    /* Shared context state (display lists, textures, etc) */
1326    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1327    ctx->Shared->RefCount--;
1328    assert(ctx->Shared->RefCount >= 0);
1329    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1330    if (ctx->Shared->RefCount == 0) {
1331       /* free shared state */
1332       free_shared_state( ctx, ctx->Shared );
1333    }
1334
1335    if (ctx->Extensions.String)
1336       FREE((void *) ctx->Extensions.String);
1337 }
1338
1339
1340 /**
1341  * Destroy a GLcontext structure.
1342  *
1343  * \param ctx GL context.
1344  *
1345  * Calls _mesa_free_context_data() and frees the GLcontext structure itself.
1346  */
1347 void
1348 _mesa_destroy_context( GLcontext *ctx )
1349 {
1350    if (ctx) {
1351       _mesa_free_context_data(ctx);
1352       FREE( (void *) ctx );
1353    }
1354 }
1355
1356
1357 #if _HAVE_FULL_GL
1358 /**
1359  * Copy attribute groups from one context to another.
1360  *
1361  * \param src source context
1362  * \param dst destination context
1363  * \param mask bitwise OR of GL_*_BIT flags
1364  *
1365  * According to the bits specified in \p mask, copies the corresponding
1366  * attributes from \p src into \p dst.  For many of the attributes a simple \c
1367  * memcpy is not enough due to the existence of internal pointers in their data
1368  * structures.
1369  */
1370 void
1371 _mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1372 {
1373    if (mask & GL_ACCUM_BUFFER_BIT) {
1374       /* OK to memcpy */
1375       dst->Accum = src->Accum;
1376    }
1377    if (mask & GL_COLOR_BUFFER_BIT) {
1378       /* OK to memcpy */
1379       dst->Color = src->Color;
1380    }
1381    if (mask & GL_CURRENT_BIT) {
1382       /* OK to memcpy */
1383       dst->Current = src->Current;
1384    }
1385    if (mask & GL_DEPTH_BUFFER_BIT) {
1386       /* OK to memcpy */
1387       dst->Depth = src->Depth;
1388    }
1389    if (mask & GL_ENABLE_BIT) {
1390       /* no op */
1391    }
1392    if (mask & GL_EVAL_BIT) {
1393       /* OK to memcpy */
1394       dst->Eval = src->Eval;
1395    }
1396    if (mask & GL_FOG_BIT) {
1397       /* OK to memcpy */
1398       dst->Fog = src->Fog;
1399    }
1400    if (mask & GL_HINT_BIT) {
1401       /* OK to memcpy */
1402       dst->Hint = src->Hint;
1403    }
1404    if (mask & GL_LIGHTING_BIT) {
1405       GLuint i;
1406       /* begin with memcpy */
1407       MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light) );
1408       /* fixup linked lists to prevent pointer insanity */
1409       make_empty_list( &(dst->Light.EnabledList) );
1410       for (i = 0; i < MAX_LIGHTS; i++) {
1411          if (dst->Light.Light[i].Enabled) {
1412             insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
1413          }
1414       }
1415    }
1416    if (mask & GL_LINE_BIT) {
1417       /* OK to memcpy */
1418       dst->Line = src->Line;
1419    }
1420    if (mask & GL_LIST_BIT) {
1421       /* OK to memcpy */
1422       dst->List = src->List;
1423    }
1424    if (mask & GL_PIXEL_MODE_BIT) {
1425       /* OK to memcpy */
1426       dst->Pixel = src->Pixel;
1427    }
1428    if (mask & GL_POINT_BIT) {
1429       /* OK to memcpy */
1430       dst->Point = src->Point;
1431    }
1432    if (mask & GL_POLYGON_BIT) {
1433       /* OK to memcpy */
1434       dst->Polygon = src->Polygon;
1435    }
1436    if (mask & GL_POLYGON_STIPPLE_BIT) {
1437       /* Use loop instead of MEMCPY due to problem with Portland Group's
1438        * C compiler.  Reported by John Stone.
1439        */
1440       GLuint i;
1441       for (i = 0; i < 32; i++) {
1442          dst->PolygonStipple[i] = src->PolygonStipple[i];
1443       }
1444    }
1445    if (mask & GL_SCISSOR_BIT) {
1446       /* OK to memcpy */
1447       dst->Scissor = src->Scissor;
1448    }
1449    if (mask & GL_STENCIL_BUFFER_BIT) {
1450       /* OK to memcpy */
1451       dst->Stencil = src->Stencil;
1452    }
1453    if (mask & GL_TEXTURE_BIT) {
1454       /* Cannot memcpy because of pointers */
1455       _mesa_copy_texture_state(src, dst);
1456    }
1457    if (mask & GL_TRANSFORM_BIT) {
1458       /* OK to memcpy */
1459       dst->Transform = src->Transform;
1460    }
1461    if (mask & GL_VIEWPORT_BIT) {
1462       /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
1463       dst->Viewport.X = src->Viewport.X;
1464       dst->Viewport.Y = src->Viewport.Y;
1465       dst->Viewport.Width = src->Viewport.Width;
1466       dst->Viewport.Height = src->Viewport.Height;
1467       dst->Viewport.Near = src->Viewport.Near;
1468       dst->Viewport.Far = src->Viewport.Far;
1469       _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
1470    }
1471
1472    /* XXX FIXME:  Call callbacks?
1473     */
1474    dst->NewState = _NEW_ALL;
1475 }
1476 #endif
1477
1478
1479 /**
1480  * Check if the given context can render into the given framebuffer
1481  * by checking visual attributes.
1482  * \return GL_TRUE if compatible, GL_FALSE otherwise.
1483  */
1484 static GLboolean
1485 check_compatible(const GLcontext *ctx, const GLframebuffer *buffer)
1486 {
1487    const GLvisual *ctxvis = &ctx->Visual;
1488    const GLvisual *bufvis = &buffer->Visual;
1489
1490    if (ctxvis == bufvis)
1491       return GL_TRUE;
1492
1493    if (ctxvis->rgbMode != bufvis->rgbMode)
1494       return GL_FALSE;
1495    if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
1496       return GL_FALSE;
1497    if (ctxvis->stereoMode && !bufvis->stereoMode)
1498       return GL_FALSE;
1499    if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
1500       return GL_FALSE;
1501    if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
1502       return GL_FALSE;
1503    if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
1504       return GL_FALSE;
1505    if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
1506       return GL_FALSE;
1507    if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
1508       return GL_FALSE;
1509    if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
1510       return GL_FALSE;
1511    if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
1512       return GL_FALSE;
1513    if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
1514       return GL_FALSE;
1515
1516    return GL_TRUE;
1517 }
1518
1519
1520 /**
1521  * Do one-time initialization for the given framebuffer.  Specifically,
1522  * ask the driver for the window's current size and update the framebuffer
1523  * object to match.
1524  * Really, the device driver should totally take care of this.
1525  */
1526 static void
1527 initialize_framebuffer_size(GLcontext *ctx, GLframebuffer *fb)
1528 {
1529    GLuint width, height;
1530    ASSERT(ctx->Driver.GetBufferSize);
1531    ctx->Driver.GetBufferSize(fb, &width, &height);
1532    if (ctx->Driver.ResizeBuffers)
1533       ctx->Driver.ResizeBuffers(ctx, fb, width, height);
1534    fb->Initialized = GL_TRUE;
1535 }
1536
1537
1538 /**
1539  * Bind the given context to the given drawBuffer and readBuffer and
1540  * make it the current context for the calling thread.
1541  * We'll render into the drawBuffer and read pixels from the
1542  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1543  *
1544  * We check that the context's and framebuffer's visuals are compatible
1545  * and return immediately if they're not.
1546  *
1547  * \param newCtx  the new GL context. If NULL then there will be no current GL
1548  *                context.
1549  * \param drawBuffer  the drawing framebuffer
1550  * \param readBuffer  the reading framebuffer
1551  */
1552 void
1553 _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
1554                     GLframebuffer *readBuffer )
1555 {
1556    if (MESA_VERBOSE & VERBOSE_API)
1557       _mesa_debug(newCtx, "_mesa_make_current()\n");
1558
1559    /* Check that the context's and framebuffer's visuals are compatible.
1560     */
1561    if (newCtx && drawBuffer && newCtx->DrawBuffer != drawBuffer) {
1562       if (!check_compatible(newCtx, drawBuffer))
1563          return;
1564    }
1565    if (newCtx && readBuffer && newCtx->ReadBuffer != readBuffer) {
1566       if (!check_compatible(newCtx, readBuffer))
1567          return;
1568    }
1569
1570 #if !defined(IN_DRI_DRIVER)
1571    /* We call this function periodically (just here for now) in
1572     * order to detect when multithreading has begun.  In a DRI driver, this
1573     * step is done by the driver loader (e.g., libGL).
1574     */
1575    _glapi_check_multithread();
1576 #endif /* !defined(IN_DRI_DRIVER) */
1577
1578    _glapi_set_context((void *) newCtx);
1579    ASSERT(_mesa_get_current_context() == newCtx);
1580
1581    if (!newCtx) {
1582       _glapi_set_dispatch(NULL);  /* none current */
1583    }
1584    else {
1585       _glapi_set_dispatch(newCtx->CurrentDispatch);
1586
1587       if (drawBuffer && readBuffer) {
1588          /* TODO: check if newCtx and buffer's visual match??? */
1589
1590          ASSERT(drawBuffer->Name == 0);
1591          ASSERT(readBuffer->Name == 0);
1592          newCtx->WinSysDrawBuffer = drawBuffer;
1593          newCtx->WinSysReadBuffer = readBuffer;
1594          /* don't replace user-buffer bindings with window system buffer */
1595          if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
1596             newCtx->DrawBuffer = drawBuffer;
1597             newCtx->ReadBuffer = readBuffer;
1598          }
1599
1600          newCtx->NewState |= _NEW_BUFFERS;
1601
1602 #if _HAVE_FULL_GL
1603          if (!drawBuffer->Initialized) {
1604             initialize_framebuffer_size(newCtx, drawBuffer);
1605          }
1606          if (readBuffer != drawBuffer && !readBuffer->Initialized) {
1607             initialize_framebuffer_size(newCtx, readBuffer);
1608          }
1609 #endif
1610          if (newCtx->FirstTimeCurrent) {
1611             /* set initial viewport and scissor size now */
1612             _mesa_set_viewport(newCtx, 0, 0,
1613                                drawBuffer->Width, drawBuffer->Height);
1614
1615             _mesa_set_scissor(newCtx, 0, 0,
1616                               drawBuffer->Width,
1617                               drawBuffer->Height );
1618          }
1619       }
1620
1621       /* We can use this to help debug user's problems.  Tell them to set
1622        * the MESA_INFO env variable before running their app.  Then the
1623        * first time each context is made current we'll print some useful
1624        * information.
1625        */
1626       if (newCtx->FirstTimeCurrent) {
1627          if (_mesa_getenv("MESA_INFO")) {
1628             _mesa_print_info();
1629          }
1630          newCtx->FirstTimeCurrent = GL_FALSE;
1631       }
1632    }
1633 }
1634
1635
1636 /**
1637  * Make context 'ctx' share the display lists, textures and programs
1638  * that are associated with 'ctxToShare'.
1639  * Any display lists, textures or programs associated with 'ctx' will
1640  * be deleted if nobody else is sharing them.
1641  */
1642 GLboolean
1643 _mesa_share_state(GLcontext *ctx, GLcontext *ctxToShare)
1644 {
1645    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1646       ctx->Shared->RefCount--;
1647       if (ctx->Shared->RefCount == 0) {
1648          free_shared_state(ctx, ctx->Shared);
1649       }
1650       ctx->Shared = ctxToShare->Shared;
1651       ctx->Shared->RefCount++;
1652       return GL_TRUE;
1653    }
1654    else {
1655       return GL_FALSE;
1656    }
1657 }
1658
1659
1660
1661 /**
1662  * Get current context for the calling thread.
1663  *
1664  * \return pointer to the current GL context.
1665  *
1666  * Calls _glapi_get_context(). This isn't the fastest way to get the current
1667  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in context.h.
1668  */
1669 GLcontext *
1670 _mesa_get_current_context( void )
1671 {
1672    return (GLcontext *) _glapi_get_context();
1673 }
1674
1675 /**
1676  * Get context's current API dispatch table.
1677  *
1678  * It'll either be the immediate-mode execute dispatcher or the display list
1679  * compile dispatcher.
1680  *
1681  * \param ctx GL context.
1682  *
1683  * \return pointer to dispatch_table.
1684  *
1685  * Simply returns __GLcontextRec::CurrentDispatch.
1686  */
1687 struct _glapi_table *
1688 _mesa_get_dispatch(GLcontext *ctx)
1689 {
1690    return ctx->CurrentDispatch;
1691 }
1692
1693 /*@}*/
1694
1695
1696 /**********************************************************************/
1697 /** \name Miscellaneous functions                                     */
1698 /**********************************************************************/
1699 /*@{*/
1700
1701 /**
1702  * Record an error.
1703  *
1704  * \param ctx GL context.
1705  * \param error error code.
1706  *
1707  * Records the given error code and call the driver's dd_function_table::Error
1708  * function if defined.
1709  *
1710  * \sa
1711  * This is called via _mesa_error().
1712  */
1713 void
1714 _mesa_record_error( GLcontext *ctx, GLenum error )
1715 {
1716    if (!ctx)
1717       return;
1718
1719    if (ctx->ErrorValue == GL_NO_ERROR) {
1720       ctx->ErrorValue = error;
1721    }
1722
1723    /* Call device driver's error handler, if any.  This is used on the Mac. */
1724    if (ctx->Driver.Error) {
1725       (*ctx->Driver.Error)( ctx );
1726    }
1727 }
1728
1729 /**
1730  * Execute glFinish().
1731  *
1732  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1733  * dd_function_table::Finish driver callback, if not NULL.
1734  */
1735 void GLAPIENTRY
1736 _mesa_Finish( void )
1737 {
1738    GET_CURRENT_CONTEXT(ctx);
1739    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1740    if (ctx->Driver.Finish) {
1741       (*ctx->Driver.Finish)( ctx );
1742    }
1743 }
1744
1745 /**
1746  * Execute glFlush().
1747  *
1748  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1749  * dd_function_table::Flush driver callback, if not NULL.
1750  */
1751 void GLAPIENTRY
1752 _mesa_Flush( void )
1753 {
1754    GET_CURRENT_CONTEXT(ctx);
1755    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1756    if (ctx->Driver.Flush) {
1757       (*ctx->Driver.Flush)( ctx );
1758    }
1759 }
1760
1761
1762 /*@}*/