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