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-2006  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 _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 #if _HAVE_FULL_GL
 628       _math_init();
 629
 630       for (i = 0; i < 256; i++) {
 631          _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
 632       }
 633 #endif
 634
 635 #ifdef USE_SPARC_ASM
 636       _mesa_init_sparc_glapi_relocs();
 637 #endif
 638       if (_mesa_getenv("MESA_DEBUG")) {
 639          _glapi_noop_enable_warnings(GL_TRUE);
 640          _glapi_set_warning_func( (_glapi_warning_func) _mesa_warning );
 641       }
 642       else {
 643          _glapi_noop_enable_warnings(GL_FALSE);
 644       }
 645
 646 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
 647       _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
 648                   MESA_VERSION_STRING, __DATE__, __TIME__);
 649 #endif
 650
 651       alreadyCalled = GL_TRUE;
 652    }
 653    _glthread_UNLOCK_MUTEX(OneTimeLock);
 654 }
 655
 656
 657 /**
 658  * Allocate and initialize a shared context state structure.
 659  * Initializes the display list, texture objects and vertex programs hash
 660  * tables, allocates the texture objects. If it runs out of memory, frees
 661  * everything already allocated before returning NULL.
 662  *
 663  * \return pointer to a gl_shared_state structure on success, or NULL on
 664  * failure.
 665  */
 666 static GLboolean
 667 alloc_shared_state( GLcontext *ctx )
 668 {
 669    struct gl_shared_state *ss = CALLOC_STRUCT(gl_shared_state);
 670    if (!ss)
 671       return GL_FALSE;
 672
 673    ctx->Shared = ss;
 674
 675    _glthread_INIT_MUTEX(ss->Mutex);
 676
 677    ss->DisplayList = _mesa_NewHashTable();
 678    ss->TexObjects = _mesa_NewHashTable();
 679 #if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
 680    ss->Programs = _mesa_NewHashTable();
 681 #endif
 682
 683 #if FEATURE_ARB_vertex_program
 684    ss->DefaultVertexProgram = ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
 685    if (!ss->DefaultVertexProgram)
 686       goto cleanup;
 687 #endif
 688 #if FEATURE_ARB_fragment_program
 689    ss->DefaultFragmentProgram = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
 690    if (!ss->DefaultFragmentProgram)
 691       goto cleanup;
 692 #endif
 693 #if FEATURE_ATI_fragment_shader
 694    ss->ATIShaders = _mesa_NewHashTable();
 695    ss->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0);
 696    if (!ss->DefaultFragmentShader)
 697       goto cleanup;
 698 #endif
 699
 700    ss->BufferObjects = _mesa_NewHashTable();
 701
 702    ss->GL2Objects = _mesa_NewHashTable ();
 703
 704    ss->Default1D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D);
 705    if (!ss->Default1D)
 706       goto cleanup;
 707
 708    ss->Default2D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D);
 709    if (!ss->Default2D)
 710       goto cleanup;
 711
 712    ss->Default3D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_3D);
 713    if (!ss->Default3D)
 714       goto cleanup;
 715
 716    ss->DefaultCubeMap = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_CUBE_MAP_ARB);
 717    if (!ss->DefaultCubeMap)
 718       goto cleanup;
 719
 720    ss->DefaultRect = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_RECTANGLE_NV);
 721    if (!ss->DefaultRect)
 722       goto cleanup;
 723
 724    /* Effectively bind the default textures to all texture units */
 725    ss->Default1D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 726    ss->Default2D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 727    ss->Default3D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 728    ss->DefaultCubeMap->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 729    ss->DefaultRect->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 730
 731 #if FEATURE_EXT_framebuffer_object
 732    ss->FrameBuffers = _mesa_NewHashTable();
 733    if (!ss->FrameBuffers)
 734       goto cleanup;
 735    ss->RenderBuffers = _mesa_NewHashTable();
 736    if (!ss->RenderBuffers)
 737       goto cleanup;
 738 #endif
 739
 740
 741    return GL_TRUE;
 742
 743  cleanup:
 744    /* Ran out of memory at some point.  Free everything and return NULL */
 745    if (ss->DisplayList)
 746       _mesa_DeleteHashTable(ss->DisplayList);
 747    if (ss->TexObjects)
 748       _mesa_DeleteHashTable(ss->TexObjects);
 749 #if FEATURE_NV_vertex_program
 750    if (ss->Programs)
 751       _mesa_DeleteHashTable(ss->Programs);
 752 #endif
 753 #if FEATURE_ARB_vertex_program
 754    if (ss->DefaultVertexProgram)
 755       ctx->Driver.DeleteProgram(ctx, ss->DefaultVertexProgram);
 756 #endif
 757 #if FEATURE_ARB_fragment_program
 758    if (ss->DefaultFragmentProgram)
 759       ctx->Driver.DeleteProgram(ctx, ss->DefaultFragmentProgram);
 760 #endif
 761 #if FEATURE_ATI_fragment_shader
 762    if (ss->DefaultFragmentShader)
 763       _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
 764 #endif
 765 #if FEATURE_ARB_vertex_buffer_object
 766    if (ss->BufferObjects)
 767       _mesa_DeleteHashTable(ss->BufferObjects);
 768 #endif
 769
 770    if (ss->GL2Objects)
 771       _mesa_DeleteHashTable (ss->GL2Objects);
 772
 773 #if FEATURE_EXT_framebuffer_object
 774    if (ss->FrameBuffers)
 775       _mesa_DeleteHashTable(ss->FrameBuffers);
 776    if (ss->RenderBuffers)
 777       _mesa_DeleteHashTable(ss->RenderBuffers);
 778 #endif
 779
 780    if (ss->Default1D)
 781       (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D);
 782    if (ss->Default2D)
 783       (*ctx->Driver.DeleteTexture)(ctx, ss->Default2D);
 784    if (ss->Default3D)
 785       (*ctx->Driver.DeleteTexture)(ctx, ss->Default3D);
 786    if (ss->DefaultCubeMap)
 787       (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap);
 788    if (ss->DefaultRect)
 789       (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect);
 790    if (ss)
 791       _mesa_free(ss);
 792    return GL_FALSE;
 793 }
 794
 795 /**
 796  * Deallocate a shared state context and all children structures.
 797  *
 798  * \param ctx GL context.
 799  * \param ss shared state pointer.
 800  *
 801  * Frees the display lists, the texture objects (calling the driver texture
 802  * deletion callback to free its private data) and the vertex programs, as well
 803  * as their hash tables.
 804  *
 805  * \sa alloc_shared_state().
 806  */
 807 static void
 808 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
 809 {
 810    /* Free display lists */
 811    while (1) {
 812       GLuint list = _mesa_HashFirstEntry(ss->DisplayList);
 813       if (list) {
 814          _mesa_destroy_list(ctx, list);
 815       }
 816       else {
 817          break;
 818       }
 819    }
 820    _mesa_DeleteHashTable(ss->DisplayList);
 821
 822    /* Free texture objects */
 823    ASSERT(ctx->Driver.DeleteTexture);
 824    /* the default textures */
 825    (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D);
 826    (*ctx->Driver.DeleteTexture)(ctx, ss->Default2D);
 827    (*ctx->Driver.DeleteTexture)(ctx, ss->Default3D);
 828    (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap);
 829    (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect);
 830    /* all other textures */
 831    while (1) {
 832       GLuint texName = _mesa_HashFirstEntry(ss->TexObjects);
 833       if (texName) {
 834          struct gl_texture_object *texObj = (struct gl_texture_object *)
 835             _mesa_HashLookup(ss->TexObjects, texName);
 836          ASSERT(texObj);
 837          (*ctx->Driver.DeleteTexture)(ctx, texObj);
 838          _mesa_HashRemove(ss->TexObjects, texName);
 839       }
 840       else {
 841          break;
 842       }
 843    }
 844    _mesa_DeleteHashTable(ss->TexObjects);
 845
 846 #if defined(FEATURE_NV_vertex_program) || defined(FEATURE_NV_fragment_program)
 847    /* Free vertex/fragment programs */
 848    while (1) {
 849       GLuint prog = _mesa_HashFirstEntry(ss->Programs);
 850       if (prog) {
 851          struct program *p = (struct program *) _mesa_HashLookup(ss->Programs,
 852                                                                  prog);
 853          ASSERT(p);
 854          ctx->Driver.DeleteProgram(ctx, p);
 855          _mesa_HashRemove(ss->Programs, prog);
 856       }
 857       else {
 858          break;
 859       }
 860    }
 861    _mesa_DeleteHashTable(ss->Programs);
 862 #endif
 863 #if FEATURE_ARB_vertex_program
 864    _mesa_delete_program(ctx, ss->DefaultVertexProgram);
 865 #endif
 866 #if FEATURE_ARB_fragment_program
 867    _mesa_delete_program(ctx, ss->DefaultFragmentProgram);
 868 #endif
 869
 870 #if FEATURE_ATI_fragment_shader
 871    /* Free ATI fragment shaders */
 872    while (1) {
 873       GLuint prog = _mesa_HashFirstEntry(ss->ATIShaders);
 874       if (prog) {
 875          struct ati_fragment_shader *s = (struct ati_fragment_shader *)
 876             _mesa_HashLookup(ss->ATIShaders, prog);
 877          ASSERT(s);
 878          _mesa_delete_ati_fragment_shader(ctx, s);
 879          _mesa_HashRemove(ss->ATIShaders, prog);
 880       }
 881       else {
 882          break;
 883       }
 884    }
 885    _mesa_DeleteHashTable(ss->ATIShaders);
 886    _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
 887 #endif
 888
 889 #if FEATURE_ARB_vertex_buffer_object
 890    _mesa_DeleteHashTable(ss->BufferObjects);
 891 #endif
 892
 893 #if FEATURE_ARB_shader_objects
 894    _mesa_DeleteHashTable (ss->GL2Objects);
 895 #endif
 896
 897 #if FEATURE_EXT_framebuffer_object
 898    _mesa_DeleteHashTable(ss->FrameBuffers);
 899    _mesa_DeleteHashTable(ss->RenderBuffers);
 900 #endif
 901
 902    _glthread_DESTROY_MUTEX(ss->Mutex);
 903
 904    FREE(ss);
 905 }
 906
 907
 908 /**
 909  * Initialize fields of gl_current_attrib (aka ctx->Current.*)
 910  */
 911 static void
 912 _mesa_init_current( GLcontext *ctx )
 913 {
 914    GLuint i;
 915
 916    /* Current group */
 917    for (i = 0; i < VERT_ATTRIB_MAX; i++) {
 918       ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
 919    }
 920    /* special cases: */
 921    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 1.0 );
 922    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
 923    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
 924    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
 925    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_FOG], 0.0, 0.0, 0.0, 0.0 );
 926
 927    ctx->Current.Index = 1;
 928    ctx->Current.EdgeFlag = GL_TRUE;
 929 }
 930
 931
 932 /**
 933  * Init vertex/fragment program native limits from logical limits.
 934  */
 935 static void
 936 init_natives(struct gl_program_constants *prog)
 937 {
 938    prog->MaxNativeInstructions = prog->MaxInstructions;
 939    prog->MaxNativeAluInstructions = prog->MaxAluInstructions;
 940    prog->MaxNativeTexInstructions = prog->MaxTexInstructions;
 941    prog->MaxNativeTexIndirections = prog->MaxTexIndirections;
 942    prog->MaxNativeAttribs = prog->MaxAttribs;
 943    prog->MaxNativeTemps = prog->MaxTemps;
 944    prog->MaxNativeAddressRegs = prog->MaxAddressRegs;
 945    prog->MaxNativeParameters = prog->MaxParameters;
 946 }
 947
 948
 949 /**
 950  * Initialize fields of gl_constants (aka ctx->Const.*).
 951  * Use defaults from config.h.  The device drivers will often override
 952  * some of these values (such as number of texture units).
 953  */
 954 static void
 955 _mesa_init_constants( GLcontext *ctx )
 956 {
 957    assert(ctx);
 958
 959    assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
 960    assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
 961
 962    /* Constants, may be overriden (usually only reduced) by device drivers */
 963    ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
 964    ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
 965    ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
 966    ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
 967    ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
 968    ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
 969    ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 970    ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
 971    ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
 972    ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
 973    ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
 974    ctx->Const.MinPointSize = MIN_POINT_SIZE;
 975    ctx->Const.MaxPointSize = MAX_POINT_SIZE;
 976    ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
 977    ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
 978    ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
 979    ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
 980    ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
 981    ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
 982    ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
 983    ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
 984    ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
 985    ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
 986    ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
 987    ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
 988    ctx->Const.MaxLights = MAX_LIGHTS;
 989    ctx->Const.MaxShininess = 128.0;
 990    ctx->Const.MaxSpotExponent = 128.0;
 991    ctx->Const.MaxViewportWidth = MAX_WIDTH;
 992    ctx->Const.MaxViewportHeight = MAX_HEIGHT;
 993 #if FEATURE_ARB_vertex_program
 994    ctx->Const.VertexProgram.MaxInstructions = MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS;
 995    ctx->Const.VertexProgram.MaxAluInstructions = 0;
 996    ctx->Const.VertexProgram.MaxTexInstructions = 0;
 997    ctx->Const.VertexProgram.MaxTexIndirections = 0;
 998    ctx->Const.VertexProgram.MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
 999    ctx->Const.VertexProgram.MaxTemps = MAX_NV_VERTEX_PROGRAM_TEMPS;
1000    ctx->Const.VertexProgram.MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
1001    ctx->Const.VertexProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
1002    ctx->Const.VertexProgram.MaxEnvParams = MAX_NV_VERTEX_PROGRAM_PARAMS;
1003    ctx->Const.VertexProgram.MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
1004    init_natives(&ctx->Const.VertexProgram);
1005 #endif
1006 #if FEATURE_ARB_fragment_program
1007    ctx->Const.FragmentProgram.MaxInstructions = MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS;
1008    ctx->Const.FragmentProgram.MaxAluInstructions = MAX_FRAGMENT_PROGRAM_ALU_INSTRUCTIONS;
1009    ctx->Const.FragmentProgram.MaxTexInstructions = MAX_FRAGMENT_PROGRAM_TEX_INSTRUCTIONS;
1010    ctx->Const.FragmentProgram.MaxTexIndirections = MAX_FRAGMENT_PROGRAM_TEX_INDIRECTIONS;
1011    ctx->Const.FragmentProgram.MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
1012    ctx->Const.FragmentProgram.MaxTemps = MAX_NV_FRAGMENT_PROGRAM_TEMPS;
1013    ctx->Const.FragmentProgram.MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
1014    ctx->Const.FragmentProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
1015    ctx->Const.FragmentProgram.MaxEnvParams = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
1016    ctx->Const.FragmentProgram.MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
1017    init_natives(&ctx->Const.FragmentProgram);
1018 #endif
1019    ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
1020    ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
1021
1022    /* If we're running in the X server, do bounds checking to prevent
1023     * segfaults and server crashes!
1024     */
1025 #if defined(XFree86LOADER) && defined(IN_MODULE)
1026    ctx->Const.CheckArrayBounds = GL_TRUE;
1027 #else
1028    ctx->Const.CheckArrayBounds = GL_FALSE;
1029 #endif
1030
1031    /* GL_ARB_draw_buffers */
1032    ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
1033
1034    /* GL_OES_read_format */
1035    ctx->Const.ColorReadFormat = GL_RGBA;
1036    ctx->Const.ColorReadType = GL_UNSIGNED_BYTE;
1037
1038 #if FEATURE_EXT_framebuffer_object
1039    ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
1040    ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
1041 #endif
1042
1043    /* sanity checks */
1044    ASSERT(ctx->Const.MaxTextureUnits == MAX2(ctx->Const.MaxTextureImageUnits, ctx->Const.MaxTextureCoordUnits));
1045    ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
1046    ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
1047 }
1048
1049
1050 /**
1051  * Initialize the attribute groups in a GL context.
1052  *
1053  * \param ctx GL context.
1054  *
1055  * Initializes all the attributes, calling the respective <tt>init*</tt>
1056  * functions for the more complex data structures.
1057  */
1058 static GLboolean
1059 init_attrib_groups( GLcontext *ctx )
1060 {
1061    assert(ctx);
1062
1063    /* Constants */
1064    _mesa_init_constants( ctx );
1065
1066    /* Extensions */
1067    _mesa_init_extensions( ctx );
1068
1069    /* Attribute Groups */
1070    _mesa_init_accum( ctx );
1071    _mesa_init_attrib( ctx );
1072    _mesa_init_buffer_objects( ctx );
1073    _mesa_init_color( ctx );
1074    _mesa_init_colortables( ctx );
1075    _mesa_init_current( ctx );
1076    _mesa_init_depth( ctx );
1077    _mesa_init_debug( ctx );
1078    _mesa_init_display_list( ctx );
1079    _mesa_init_eval( ctx );
1080    _mesa_init_feedback( ctx );
1081    _mesa_init_fog( ctx );
1082    _mesa_init_histogram( ctx );
1083    _mesa_init_hint( ctx );
1084    _mesa_init_line( ctx );
1085    _mesa_init_lighting( ctx );
1086    _mesa_init_matrix( ctx );
1087    _mesa_init_multisample( ctx );
1088    _mesa_init_pixel( ctx );
1089    _mesa_init_point( ctx );
1090    _mesa_init_polygon( ctx );
1091    _mesa_init_program( ctx );
1092    _mesa_init_query( ctx );
1093    _mesa_init_rastpos( ctx );
1094    _mesa_init_scissor( ctx );
1095    _mesa_init_shaderobjects (ctx);
1096    _mesa_init_stencil( ctx );
1097    _mesa_init_transform( ctx );
1098    _mesa_init_varray( ctx );
1099    _mesa_init_viewport( ctx );
1100
1101    if (!_mesa_init_texture( ctx ))
1102       return GL_FALSE;
1103
1104    _mesa_init_texture_s3tc( ctx );
1105    _mesa_init_texture_fxt1( ctx );
1106
1107    /* Miscellaneous */
1108    ctx->NewState = _NEW_ALL;
1109    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1110    ctx->_Facing = 0;
1111
1112    return GL_TRUE;
1113 }
1114
1115
1116 /**
1117  * This is the default function we plug into all dispatch table slots
1118  * This helps prevents a segfault when someone calls a GL function without
1119  * first checking if the extension's supported.
1120  */
1121 static int
1122 generic_nop(void)
1123 {
1124    _mesa_problem(NULL, "User called no-op dispatch function (an unsupported extension function?)");
1125    return 0;
1126 }
1127
1128
1129 /**
1130  * Allocate and initialize a new dispatch table.
1131  */
1132 static struct _glapi_table *
1133 alloc_dispatch_table(void)
1134 {
1135    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1136     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
1137     * Mesa we do this to accomodate different versions of libGL and various
1138     * DRI drivers.
1139     */
1140    GLint numEntries = MAX2(_glapi_get_dispatch_table_size(),
1141                            sizeof(struct _glapi_table) / sizeof(_glapi_proc));
1142    struct _glapi_table *table =
1143       (struct _glapi_table *) _mesa_malloc(numEntries * sizeof(_glapi_proc));
1144    if (table) {
1145       _glapi_proc *entry = (_glapi_proc *) table;
1146       GLint i;
1147       for (i = 0; i < numEntries; i++) {
1148          entry[i] = (_glapi_proc) generic_nop;
1149       }
1150    }
1151    return table;
1152 }
1153
1154
1155 /**
1156  * Initialize a GLcontext struct (rendering context).
1157  *
1158  * This includes allocating all the other structs and arrays which hang off of
1159  * the context by pointers.
1160  * Note that the driver needs to pass in its dd_function_table here since
1161  * we need to at least call driverFunctions->NewTextureObject to create the
1162  * default texture objects.
1163  *
1164  * Called by _mesa_create_context().
1165  *
1166  * Performs the imports and exports callback tables initialization, and
1167  * miscellaneous one-time initializations. If no shared context is supplied one
1168  * is allocated, and increase its reference count.  Setups the GL API dispatch
1169  * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
1170  * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1171  * for debug flags.
1172  *
1173  * \param ctx the context to initialize
1174  * \param visual describes the visual attributes for this context
1175  * \param share_list points to context to share textures, display lists,
1176  *        etc with, or NULL
1177  * \param driverFunctions table of device driver functions for this context
1178  *        to use
1179  * \param driverContext pointer to driver-specific context data
1180  */
1181 GLboolean
1182 _mesa_initialize_context( GLcontext *ctx,
1183                           const GLvisual *visual,
1184                           GLcontext *share_list,
1185                           const struct dd_function_table *driverFunctions,
1186                           void *driverContext )
1187 {
1188    ASSERT(driverContext);
1189    assert(driverFunctions->NewTextureObject);
1190    assert(driverFunctions->FreeTexImageData);
1191
1192    /* If the driver wants core Mesa to use special imports, it'll have to
1193     * override these defaults.
1194     */
1195    _mesa_init_default_imports( &(ctx->imports), driverContext );
1196
1197    /* initialize the exports (Mesa functions called by the window system) */
1198    _mesa_init_default_exports( &(ctx->exports) );
1199
1200    /* misc one-time initializations */
1201    one_time_init(ctx);
1202
1203    ctx->Visual = *visual;
1204    ctx->DrawBuffer = NULL;
1205    ctx->ReadBuffer = NULL;
1206    ctx->WinSysDrawBuffer = NULL;
1207    ctx->WinSysReadBuffer = NULL;
1208
1209    /* Plug in driver functions and context pointer here.
1210     * This is important because when we call alloc_shared_state() below
1211     * we'll call ctx->Driver.NewTextureObject() to create the default
1212     * textures.
1213     */
1214    ctx->Driver = *driverFunctions;
1215    ctx->DriverCtx = driverContext;
1216
1217    if (share_list) {
1218       /* share state with another context */
1219       ctx->Shared = share_list->Shared;
1220    }
1221    else {
1222       /* allocate new, unshared state */
1223       if (!alloc_shared_state( ctx )) {
1224          return GL_FALSE;
1225       }
1226    }
1227    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1228    ctx->Shared->RefCount++;
1229    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1230
1231    if (!init_attrib_groups( ctx )) {
1232       free_shared_state(ctx, ctx->Shared);
1233       return GL_FALSE;
1234    }
1235
1236    /* setup the API dispatch tables */
1237    ctx->Exec = alloc_dispatch_table();
1238    ctx->Save = alloc_dispatch_table();
1239    if (!ctx->Exec || !ctx->Save) {
1240       free_shared_state(ctx, ctx->Shared);
1241       if (ctx->Exec)
1242          _mesa_free(ctx->Exec);
1243    }
1244    _mesa_init_exec_table(ctx->Exec);
1245    ctx->CurrentDispatch = ctx->Exec;
1246 #if _HAVE_FULL_GL
1247    _mesa_init_dlist_table(ctx->Save);
1248    _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
1249    /* Neutral tnl module stuff */
1250    _mesa_init_exec_vtxfmt( ctx );
1251    ctx->TnlModule.Current = NULL;
1252    ctx->TnlModule.SwapCount = 0;
1253 #endif
1254
1255    ctx->_MaintainTexEnvProgram = (_mesa_getenv("MESA_TEX_PROG") != NULL);
1256    ctx->_UseTexEnvProgram = ctx->_MaintainTexEnvProgram;
1257
1258    ctx->_MaintainTnlProgram = (_mesa_getenv("MESA_TNL_PROG") != NULL);
1259    if (ctx->_MaintainTnlProgram)
1260       ctx->_MaintainTexEnvProgram = 1; /* this is required... */
1261
1262    ctx->FirstTimeCurrent = GL_TRUE;
1263
1264    return GL_TRUE;
1265 }
1266
1267
1268 /**
1269  * Allocate and initialize a GLcontext structure.
1270  * Note that the driver needs to pass in its dd_function_table here since
1271  * we need to at least call driverFunctions->NewTextureObject to initialize
1272  * the rendering context.
1273  *
1274  * \param visual a GLvisual pointer (we copy the struct contents)
1275  * \param share_list another context to share display lists with or NULL
1276  * \param driverFunctions points to the dd_function_table into which the
1277  *        driver has plugged in all its special functions.
1278  * \param driverCtx points to the device driver's private context state
1279  *
1280  * \return pointer to a new __GLcontextRec or NULL if error.
1281  */
1282 GLcontext *
1283 _mesa_create_context( const GLvisual *visual,
1284                       GLcontext *share_list,
1285                       const struct dd_function_table *driverFunctions,
1286                       void *driverContext )
1287
1288 {
1289    GLcontext *ctx;
1290
1291    ASSERT(visual);
1292    ASSERT(driverContext);
1293
1294    ctx = (GLcontext *) _mesa_calloc(sizeof(GLcontext));
1295    if (!ctx)
1296       return NULL;
1297
1298    if (_mesa_initialize_context(ctx, visual, share_list,
1299                                 driverFunctions, driverContext)) {
1300       return ctx;
1301    }
1302    else {
1303       _mesa_free(ctx);
1304       return NULL;
1305    }
1306 }
1307
1308
1309 /**
1310  * Free the data associated with the given context.
1311  *
1312  * But doesn't free the GLcontext struct itself.
1313  *
1314  * \sa _mesa_initialize_context() and init_attrib_groups().
1315  */
1316 void
1317 _mesa_free_context_data( GLcontext *ctx )
1318 {
1319    /* if we're destroying the current context, unbind it first */
1320    if (ctx == _mesa_get_current_context()) {
1321       _mesa_make_current(NULL, NULL, NULL);
1322    }
1323
1324    _mesa_free_lighting_data( ctx );
1325    _mesa_free_eval_data( ctx );
1326    _mesa_free_texture_data( ctx );
1327    _mesa_free_matrix_data( ctx );
1328    _mesa_free_viewport_data( ctx );
1329    _mesa_free_colortables_data( ctx );
1330    _mesa_free_program_data(ctx);
1331    _mesa_free_query_data(ctx);
1332
1333 #if FEATURE_ARB_vertex_buffer_object
1334    _mesa_delete_buffer_object(ctx, ctx->Array.NullBufferObj);
1335 #endif
1336
1337    /* free dispatch tables */
1338    _mesa_free(ctx->Exec);
1339    _mesa_free(ctx->Save);
1340
1341    /* Shared context state (display lists, textures, etc) */
1342    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1343    ctx->Shared->RefCount--;
1344    assert(ctx->Shared->RefCount >= 0);
1345    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1346    if (ctx->Shared->RefCount == 0) {
1347       /* free shared state */
1348       free_shared_state( ctx, ctx->Shared );
1349    }
1350
1351    if (ctx->Extensions.String)
1352       FREE((void *) ctx->Extensions.String);
1353 }
1354
1355
1356 /**
1357  * Destroy a GLcontext structure.
1358  *
1359  * \param ctx GL context.
1360  *
1361  * Calls _mesa_free_context_data() and frees the GLcontext structure itself.
1362  */
1363 void
1364 _mesa_destroy_context( GLcontext *ctx )
1365 {
1366    if (ctx) {
1367       _mesa_free_context_data(ctx);
1368       FREE( (void *) ctx );
1369    }
1370 }
1371
1372
1373 #if _HAVE_FULL_GL
1374 /**
1375  * Copy attribute groups from one context to another.
1376  *
1377  * \param src source context
1378  * \param dst destination context
1379  * \param mask bitwise OR of GL_*_BIT flags
1380  *
1381  * According to the bits specified in \p mask, copies the corresponding
1382  * attributes from \p src into \p dst.  For many of the attributes a simple \c
1383  * memcpy is not enough due to the existence of internal pointers in their data
1384  * structures.
1385  */
1386 void
1387 _mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1388 {
1389    if (mask & GL_ACCUM_BUFFER_BIT) {
1390       /* OK to memcpy */
1391       dst->Accum = src->Accum;
1392    }
1393    if (mask & GL_COLOR_BUFFER_BIT) {
1394       /* OK to memcpy */
1395       dst->Color = src->Color;
1396    }
1397    if (mask & GL_CURRENT_BIT) {
1398       /* OK to memcpy */
1399       dst->Current = src->Current;
1400    }
1401    if (mask & GL_DEPTH_BUFFER_BIT) {
1402       /* OK to memcpy */
1403       dst->Depth = src->Depth;
1404    }
1405    if (mask & GL_ENABLE_BIT) {
1406       /* no op */
1407    }
1408    if (mask & GL_EVAL_BIT) {
1409       /* OK to memcpy */
1410       dst->Eval = src->Eval;
1411    }
1412    if (mask & GL_FOG_BIT) {
1413       /* OK to memcpy */
1414       dst->Fog = src->Fog;
1415    }
1416    if (mask & GL_HINT_BIT) {
1417       /* OK to memcpy */
1418       dst->Hint = src->Hint;
1419    }
1420    if (mask & GL_LIGHTING_BIT) {
1421       GLuint i;
1422       /* begin with memcpy */
1423       dst->Light = src->Light;
1424       /* fixup linked lists to prevent pointer insanity */
1425       make_empty_list( &(dst->Light.EnabledList) );
1426       for (i = 0; i < MAX_LIGHTS; i++) {
1427          if (dst->Light.Light[i].Enabled) {
1428             insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
1429          }
1430       }
1431    }
1432    if (mask & GL_LINE_BIT) {
1433       /* OK to memcpy */
1434       dst->Line = src->Line;
1435    }
1436    if (mask & GL_LIST_BIT) {
1437       /* OK to memcpy */
1438       dst->List = src->List;
1439    }
1440    if (mask & GL_PIXEL_MODE_BIT) {
1441       /* OK to memcpy */
1442       dst->Pixel = src->Pixel;
1443    }
1444    if (mask & GL_POINT_BIT) {
1445       /* OK to memcpy */
1446       dst->Point = src->Point;
1447    }
1448    if (mask & GL_POLYGON_BIT) {
1449       /* OK to memcpy */
1450       dst->Polygon = src->Polygon;
1451    }
1452    if (mask & GL_POLYGON_STIPPLE_BIT) {
1453       /* Use loop instead of MEMCPY due to problem with Portland Group's
1454        * C compiler.  Reported by John Stone.
1455        */
1456       GLuint i;
1457       for (i = 0; i < 32; i++) {
1458          dst->PolygonStipple[i] = src->PolygonStipple[i];
1459       }
1460    }
1461    if (mask & GL_SCISSOR_BIT) {
1462       /* OK to memcpy */
1463       dst->Scissor = src->Scissor;
1464    }
1465    if (mask & GL_STENCIL_BUFFER_BIT) {
1466       /* OK to memcpy */
1467       dst->Stencil = src->Stencil;
1468    }
1469    if (mask & GL_TEXTURE_BIT) {
1470       /* Cannot memcpy because of pointers */
1471       _mesa_copy_texture_state(src, dst);
1472    }
1473    if (mask & GL_TRANSFORM_BIT) {
1474       /* OK to memcpy */
1475       dst->Transform = src->Transform;
1476    }
1477    if (mask & GL_VIEWPORT_BIT) {
1478       /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
1479       dst->Viewport.X = src->Viewport.X;
1480       dst->Viewport.Y = src->Viewport.Y;
1481       dst->Viewport.Width = src->Viewport.Width;
1482       dst->Viewport.Height = src->Viewport.Height;
1483       dst->Viewport.Near = src->Viewport.Near;
1484       dst->Viewport.Far = src->Viewport.Far;
1485       _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
1486    }
1487
1488    /* XXX FIXME:  Call callbacks?
1489     */
1490    dst->NewState = _NEW_ALL;
1491 }
1492 #endif
1493
1494
1495 /**
1496  * Check if the given context can render into the given framebuffer
1497  * by checking visual attributes.
1498  *
1499  * XXX this may go away someday because we're moving toward more freedom
1500  * in binding contexts to drawables with different visual attributes.
1501  * The GL_EXT_f_b_o extension is prompting some of that.
1502  *
1503  * \return GL_TRUE if compatible, GL_FALSE otherwise.
1504  */
1505 static GLboolean
1506 check_compatible(const GLcontext *ctx, const GLframebuffer *buffer)
1507 {
1508    const GLvisual *ctxvis = &ctx->Visual;
1509    const GLvisual *bufvis = &buffer->Visual;
1510
1511    if (ctxvis == bufvis)
1512       return GL_TRUE;
1513
1514    if (ctxvis->rgbMode != bufvis->rgbMode)
1515       return GL_FALSE;
1516 #if 0
1517    /* disabling this fixes the fgl_glxgears pbuffer demo */
1518    if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
1519       return GL_FALSE;
1520 #endif
1521    if (ctxvis->stereoMode && !bufvis->stereoMode)
1522       return GL_FALSE;
1523    if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
1524       return GL_FALSE;
1525    if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
1526       return GL_FALSE;
1527    if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
1528       return GL_FALSE;
1529    if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
1530       return GL_FALSE;
1531    if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
1532       return GL_FALSE;
1533    if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
1534       return GL_FALSE;
1535    if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
1536       return GL_FALSE;
1537    if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
1538       return GL_FALSE;
1539
1540    return GL_TRUE;
1541 }
1542
1543
1544 /**
1545  * Do one-time initialization for the given framebuffer.  Specifically,
1546  * ask the driver for the window's current size and update the framebuffer
1547  * object to match.
1548  * Really, the device driver should totally take care of this.
1549  */
1550 static void
1551 initialize_framebuffer_size(GLcontext *ctx, GLframebuffer *fb)
1552 {
1553    GLuint width, height;
1554    ASSERT(ctx->Driver.GetBufferSize);
1555    ctx->Driver.GetBufferSize(fb, &width, &height);
1556    if (ctx->Driver.ResizeBuffers)
1557       ctx->Driver.ResizeBuffers(ctx, fb, width, height);
1558    fb->Initialized = GL_TRUE;
1559 }
1560
1561
1562 /**
1563  * Bind the given context to the given drawBuffer and readBuffer and
1564  * make it the current context for the calling thread.
1565  * We'll render into the drawBuffer and read pixels from the
1566  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1567  *
1568  * We check that the context's and framebuffer's visuals are compatible
1569  * and return immediately if they're not.
1570  *
1571  * \param newCtx  the new GL context. If NULL then there will be no current GL
1572  *                context.
1573  * \param drawBuffer  the drawing framebuffer
1574  * \param readBuffer  the reading framebuffer
1575  */
1576 void
1577 _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
1578                     GLframebuffer *readBuffer )
1579 {
1580    if (MESA_VERBOSE & VERBOSE_API)
1581       _mesa_debug(newCtx, "_mesa_make_current()\n");
1582
1583    /* Check that the context's and framebuffer's visuals are compatible.
1584     */
1585    if (newCtx && drawBuffer && newCtx->DrawBuffer != drawBuffer) {
1586       if (!check_compatible(newCtx, drawBuffer)) {
1587          _mesa_warning(newCtx,
1588               "MakeCurrent: incompatible visuals for context and drawbuffer");
1589          return;
1590       }
1591    }
1592    if (newCtx && readBuffer && newCtx->ReadBuffer != readBuffer) {
1593       if (!check_compatible(newCtx, readBuffer)) {
1594          _mesa_warning(newCtx,
1595               "MakeCurrent: incompatible visuals for context and readbuffer");
1596          return;
1597       }
1598    }
1599
1600 #if !defined(IN_DRI_DRIVER)
1601    /* We call this function periodically (just here for now) in
1602     * order to detect when multithreading has begun.  In a DRI driver, this
1603     * step is done by the driver loader (e.g., libGL).
1604     */
1605    _glapi_check_multithread();
1606 #endif /* !defined(IN_DRI_DRIVER) */
1607
1608    _glapi_set_context((void *) newCtx);
1609    ASSERT(_mesa_get_current_context() == newCtx);
1610
1611    if (!newCtx) {
1612       _glapi_set_dispatch(NULL);  /* none current */
1613    }
1614    else {
1615       _glapi_set_dispatch(newCtx->CurrentDispatch);
1616
1617       if (drawBuffer && readBuffer) {
1618          /* TODO: check if newCtx and buffer's visual match??? */
1619
1620          ASSERT(drawBuffer->Name == 0);
1621          ASSERT(readBuffer->Name == 0);
1622          newCtx->WinSysDrawBuffer = drawBuffer;
1623          newCtx->WinSysReadBuffer = readBuffer;
1624          /* don't replace user-buffer bindings with window system buffer */
1625          if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
1626             newCtx->DrawBuffer = drawBuffer;
1627             newCtx->ReadBuffer = readBuffer;
1628          }
1629
1630          newCtx->NewState |= _NEW_BUFFERS;
1631
1632 #if _HAVE_FULL_GL
1633          if (!drawBuffer->Initialized) {
1634             initialize_framebuffer_size(newCtx, drawBuffer);
1635          }
1636          if (readBuffer != drawBuffer && !readBuffer->Initialized) {
1637             initialize_framebuffer_size(newCtx, readBuffer);
1638          }
1639 #endif
1640          if (newCtx->FirstTimeCurrent) {
1641             /* set initial viewport and scissor size now */
1642             _mesa_set_viewport(newCtx, 0, 0,
1643                                drawBuffer->Width, drawBuffer->Height);
1644
1645             _mesa_set_scissor(newCtx, 0, 0,
1646                               drawBuffer->Width,
1647                               drawBuffer->Height );
1648          }
1649       }
1650
1651       /* We can use this to help debug user's problems.  Tell them to set
1652        * the MESA_INFO env variable before running their app.  Then the
1653        * first time each context is made current we'll print some useful
1654        * information.
1655        */
1656       if (newCtx->FirstTimeCurrent) {
1657          if (_mesa_getenv("MESA_INFO")) {
1658             _mesa_print_info();
1659          }
1660          newCtx->FirstTimeCurrent = GL_FALSE;
1661       }
1662    }
1663 }
1664
1665
1666 /**
1667  * Make context 'ctx' share the display lists, textures and programs
1668  * that are associated with 'ctxToShare'.
1669  * Any display lists, textures or programs associated with 'ctx' will
1670  * be deleted if nobody else is sharing them.
1671  */
1672 GLboolean
1673 _mesa_share_state(GLcontext *ctx, GLcontext *ctxToShare)
1674 {
1675    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1676       ctx->Shared->RefCount--;
1677       if (ctx->Shared->RefCount == 0) {
1678          free_shared_state(ctx, ctx->Shared);
1679       }
1680       ctx->Shared = ctxToShare->Shared;
1681       ctx->Shared->RefCount++;
1682       return GL_TRUE;
1683    }
1684    else {
1685       return GL_FALSE;
1686    }
1687 }
1688
1689
1690
1691 /**
1692  * Get current context for the calling thread.
1693  *
1694  * \return pointer to the current GL context.
1695  *
1696  * Calls _glapi_get_context(). This isn't the fastest way to get the current
1697  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in context.h.
1698  */
1699 GLcontext *
1700 _mesa_get_current_context( void )
1701 {
1702    return (GLcontext *) _glapi_get_context();
1703 }
1704
1705 /**
1706  * Get context's current API dispatch table.
1707  *
1708  * It'll either be the immediate-mode execute dispatcher or the display list
1709  * compile dispatcher.
1710  *
1711  * \param ctx GL context.
1712  *
1713  * \return pointer to dispatch_table.
1714  *
1715  * Simply returns __GLcontextRec::CurrentDispatch.
1716  */
1717 struct _glapi_table *
1718 _mesa_get_dispatch(GLcontext *ctx)
1719 {
1720    return ctx->CurrentDispatch;
1721 }
1722
1723 /*@}*/
1724
1725
1726 /**********************************************************************/
1727 /** \name Miscellaneous functions                                     */
1728 /**********************************************************************/
1729 /*@{*/
1730
1731 /**
1732  * Record an error.
1733  *
1734  * \param ctx GL context.
1735  * \param error error code.
1736  *
1737  * Records the given error code and call the driver's dd_function_table::Error
1738  * function if defined.
1739  *
1740  * \sa
1741  * This is called via _mesa_error().
1742  */
1743 void
1744 _mesa_record_error( GLcontext *ctx, GLenum error )
1745 {
1746    if (!ctx)
1747       return;
1748
1749    if (ctx->ErrorValue == GL_NO_ERROR) {
1750       ctx->ErrorValue = error;
1751    }
1752
1753    /* Call device driver's error handler, if any.  This is used on the Mac. */
1754    if (ctx->Driver.Error) {
1755       (*ctx->Driver.Error)( ctx );
1756    }
1757 }
1758
1759 /**
1760  * Execute glFinish().
1761  *
1762  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1763  * dd_function_table::Finish driver callback, if not NULL.
1764  */
1765 void GLAPIENTRY
1766 _mesa_Finish( void )
1767 {
1768    GET_CURRENT_CONTEXT(ctx);
1769    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1770    if (ctx->Driver.Finish) {
1771       (*ctx->Driver.Finish)( ctx );
1772    }
1773 }
1774
1775 /**
1776  * Execute glFlush().
1777  *
1778  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1779  * dd_function_table::Flush driver callback, if not NULL.
1780  */
1781 void GLAPIENTRY
1782 _mesa_Flush( void )
1783 {
1784    GET_CURRENT_CONTEXT(ctx);
1785    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1786    if (ctx->Driver.Flush) {
1787       (*ctx->Driver.Flush)( ctx );
1788    }
1789 }
1790
1791
1792 /*@}*/