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.3
  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 "vtxfmt.h"
 125 #if _HAVE_FULL_GL
 126 #include "math/m_translate.h"
 127 #include "math/m_matrix.h"
 128 #include "math/m_xform.h"
 129 #include "math/mathmod.h"
 130 #endif
 131 #include "shaderobjects.h"
 132
 133 #ifdef USE_SPARC_ASM
 134 #include "sparc/sparc.h"
 135 #endif
 136
 137 #ifndef MESA_VERBOSE
 138 int MESA_VERBOSE = 0;
 139 #endif
 140
 141 #ifndef MESA_DEBUG_FLAGS
 142 int MESA_DEBUG_FLAGS = 0;
 143 #endif
 144
 145
 146 /* ubyte -> float conversion */
 147 GLfloat _mesa_ubyte_to_float_color_tab[256];
 148
 149 static void
 150 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss );
 151
 152
 153 /**********************************************************************/
 154 /** \name OpenGL SI-style interface (new in Mesa 3.5)
 155  *
 156  * \if subset
 157  * \note Most of these functions are never called in the Mesa subset.
 158  * \endif
 159  */
 160 /*@{*/
 161
 162 /**
 163  * Destroy context callback.
 164  *
 165  * \param gc context.
 166  * \return GL_TRUE on success, or GL_FALSE on failure.
 167  *
 168  * \ifnot subset
 169  * Called by window system/device driver (via __GLexports::destroyCurrent) when
 170  * the rendering context is to be destroyed.
 171  * \endif
 172  *
 173  * Frees the context data and the context structure.
 174  */
 175 GLboolean
 176 _mesa_destroyContext(__GLcontext *gc)
 177 {
 178    if (gc) {
 179       _mesa_free_context_data(gc);
 180       _mesa_free(gc);
 181    }
 182    return GL_TRUE;
 183 }
 184
 185 /**
 186  * Unbind context callback.
 187  *
 188  * \param gc context.
 189  * \return GL_TRUE on success, or GL_FALSE on failure.
 190  *
 191  * \ifnot subset
 192  * Called by window system/device driver (via __GLexports::loseCurrent)
 193  * when the rendering context is made non-current.
 194  * \endif
 195  *
 196  * No-op
 197  */
 198 GLboolean
 199 _mesa_loseCurrent(__GLcontext *gc)
 200 {
 201    /* XXX unbind context from thread */
 202    (void) gc;
 203    return GL_TRUE;
 204 }
 205
 206 /**
 207  * Bind context callback.
 208  *
 209  * \param gc context.
 210  * \return GL_TRUE on success, or GL_FALSE on failure.
 211  *
 212  * \ifnot subset
 213  * Called by window system/device driver (via __GLexports::makeCurrent)
 214  * when the rendering context is made current.
 215  * \endif
 216  *
 217  * No-op
 218  */
 219 GLboolean
 220 _mesa_makeCurrent(__GLcontext *gc)
 221 {
 222    /* XXX bind context to thread */
 223    (void) gc;
 224    return GL_TRUE;
 225 }
 226
 227 /**
 228  * Share context callback.
 229  *
 230  * \param gc context.
 231  * \param gcShare shared context.
 232  * \return GL_TRUE on success, or GL_FALSE on failure.
 233  *
 234  * \ifnot subset
 235  * Called by window system/device driver (via __GLexports::shareContext)
 236  * \endif
 237  *
 238  * Update the shared context reference count, gl_shared_state::RefCount.
 239  */
 240 GLboolean
 241 _mesa_shareContext(__GLcontext *gc, __GLcontext *gcShare)
 242 {
 243    if (gc && gcShare && gc->Shared && gcShare->Shared) {
 244       gc->Shared->RefCount--;
 245       if (gc->Shared->RefCount == 0) {
 246          free_shared_state(gc, gc->Shared);
 247       }
 248       gc->Shared = gcShare->Shared;
 249       gc->Shared->RefCount++;
 250       return GL_TRUE;
 251    }
 252    else {
 253       return GL_FALSE;
 254    }
 255 }
 256
 257
 258 #if _HAVE_FULL_GL
 259 /**
 260  * Copy context callback.
 261  */
 262 GLboolean
 263 _mesa_copyContext(__GLcontext *dst, const __GLcontext *src, GLuint mask)
 264 {
 265    if (dst && src) {
 266       _mesa_copy_context( src, dst, mask );
 267       return GL_TRUE;
 268    }
 269    else {
 270       return GL_FALSE;
 271    }
 272 }
 273 #endif
 274
 275 /** No-op */
 276 GLboolean
 277 _mesa_forceCurrent(__GLcontext *gc)
 278 {
 279    (void) gc;
 280    return GL_TRUE;
 281 }
 282
 283 /**
 284  * Windows/buffer resizing notification callback.
 285  *
 286  * \param gc GL context.
 287  * \return GL_TRUE on success, or GL_FALSE on failure.
 288  */
 289 GLboolean
 290 _mesa_notifyResize(__GLcontext *gc)
 291 {
 292    GLint x, y;
 293    GLuint width, height;
 294    __GLdrawablePrivate *d = gc->imports.getDrawablePrivate(gc);
 295    if (!d || !d->getDrawableSize)
 296       return GL_FALSE;
 297    d->getDrawableSize( d, &x, &y, &width, &height );
 298    /* update viewport, resize software buffers, etc. */
 299    return GL_TRUE;
 300 }
 301
 302 /**
 303  * Window/buffer destruction notification callback.
 304  *
 305  * \param gc GL context.
 306  *
 307  * Called when the context's window/buffer is going to be destroyed.
 308  *
 309  * No-op
 310  */
 311 void
 312 _mesa_notifyDestroy(__GLcontext *gc)
 313 {
 314    /* Unbind from it. */
 315    (void) gc;
 316 }
 317
 318 /**
 319  * Swap buffers notification callback.
 320  *
 321  * \param gc GL context.
 322  *
 323  * Called by window system just before swapping buffers.
 324  * We have to finish any pending rendering.
 325  */
 326 void
 327 _mesa_notifySwapBuffers(__GLcontext *gc)
 328 {
 329    FLUSH_VERTICES( gc, 0 );
 330 }
 331
 332 /** No-op */
 333 struct __GLdispatchStateRec *
 334 _mesa_dispatchExec(__GLcontext *gc)
 335 {
 336    (void) gc;
 337    return NULL;
 338 }
 339
 340 /** No-op */
 341 void
 342 _mesa_beginDispatchOverride(__GLcontext *gc)
 343 {
 344    (void) gc;
 345 }
 346
 347 /** No-op */
 348 void
 349 _mesa_endDispatchOverride(__GLcontext *gc)
 350 {
 351    (void) gc;
 352 }
 353
 354 /**
 355  * \ifnot subset
 356  * Setup the exports.
 357  *
 358  * The window system will call these functions when it needs Mesa to do
 359  * something.
 360  *
 361  * \note Device drivers should override these functions!  For example,
 362  * the Xlib driver should plug in the XMesa*-style functions into this
 363  * structure.  The XMesa-style functions should then call the _mesa_*
 364  * version of these functions.  This is an approximation to OO design
 365  * (inheritance and virtual functions).
 366  * \endif
 367  *
 368  * \if subset
 369  * No-op.
 370  *
 371  * \endif
 372  */
 373 static void
 374 _mesa_init_default_exports(__GLexports *exports)
 375 {
 376 #if _HAVE_FULL_GL
 377     exports->destroyContext = _mesa_destroyContext;
 378     exports->loseCurrent = _mesa_loseCurrent;
 379     exports->makeCurrent = _mesa_makeCurrent;
 380     exports->shareContext = _mesa_shareContext;
 381     exports->copyContext = _mesa_copyContext;
 382     exports->forceCurrent = _mesa_forceCurrent;
 383     exports->notifyResize = _mesa_notifyResize;
 384     exports->notifyDestroy = _mesa_notifyDestroy;
 385     exports->notifySwapBuffers = _mesa_notifySwapBuffers;
 386     exports->dispatchExec = _mesa_dispatchExec;
 387     exports->beginDispatchOverride = _mesa_beginDispatchOverride;
 388     exports->endDispatchOverride = _mesa_endDispatchOverride;
 389 #else
 390     (void) exports;
 391 #endif
 392 }
 393
 394 /**
 395  * Exported OpenGL SI interface.
 396  */
 397 __GLcontext *
 398 __glCoreCreateContext(__GLimports *imports, __GLcontextModes *modes)
 399 {
 400     GLcontext *ctx;
 401
 402     ctx = (GLcontext *) (*imports->calloc)(NULL, 1, sizeof(GLcontext));
 403     if (ctx == NULL) {
 404         return NULL;
 405     }
 406
 407     /* XXX doesn't work at this time */
 408     _mesa_initialize_context(ctx, modes, NULL, NULL, NULL);
 409     ctx->imports = *imports;
 410
 411     return ctx;
 412 }
 413
 414 /**
 415  * Exported OpenGL SI interface.
 416  */
 417 void
 418 __glCoreNopDispatch(void)
 419 {
 420 #if 0
 421    /* SI */
 422    __gl_dispatch = __glNopDispatchState;
 423 #else
 424    /* Mesa */
 425    _glapi_set_dispatch(NULL);
 426 #endif
 427 }
 428
 429 /*@}*/
 430
 431
 432 /**********************************************************************/
 433 /** \name GL Visual allocation/destruction                            */
 434 /**********************************************************************/
 435 /*@{*/
 436
 437 /**
 438  * Allocates a GLvisual structure and initializes it via
 439  * _mesa_initialize_visual().
 440  *
 441  * \param rgbFlag GL_TRUE for RGB(A) mode, GL_FALSE for Color Index mode.
 442  * \param dbFlag double buffering
 443  * \param stereoFlag stereo buffer
 444  * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
 445  * is acceptable but the actual depth type will be GLushort or GLuint as
 446  * needed.
 447  * \param stencilBits requested minimum bits per stencil buffer value
 448  * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.
 449  * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
 450  * \param redBits number of bits per color component in frame buffer for RGB(A)
 451  * mode.  We always use 8 in core Mesa though.
 452  * \param greenBits same as above.
 453  * \param blueBits same as above.
 454  * \param alphaBits same as above.
 455  * \param numSamples not really used.
 456  *
 457  * \return pointer to new GLvisual or NULL if requested parameters can't be
 458  * met.
 459  *
 460  * \note Need to add params for level and numAuxBuffers (at least)
 461  */
 462 GLvisual *
 463 _mesa_create_visual( GLboolean rgbFlag,
 464                      GLboolean dbFlag,
 465                      GLboolean stereoFlag,
 466                      GLint redBits,
 467                      GLint greenBits,
 468                      GLint blueBits,
 469                      GLint alphaBits,
 470                      GLint indexBits,
 471                      GLint depthBits,
 472                      GLint stencilBits,
 473                      GLint accumRedBits,
 474                      GLint accumGreenBits,
 475                      GLint accumBlueBits,
 476                      GLint accumAlphaBits,
 477                      GLint numSamples )
 478 {
 479    GLvisual *vis = (GLvisual *) CALLOC( sizeof(GLvisual) );
 480    if (vis) {
 481       if (!_mesa_initialize_visual(vis, rgbFlag, dbFlag, stereoFlag,
 482                                    redBits, greenBits, blueBits, alphaBits,
 483                                    indexBits, depthBits, stencilBits,
 484                                    accumRedBits, accumGreenBits,
 485                                    accumBlueBits, accumAlphaBits,
 486                                    numSamples)) {
 487          FREE(vis);
 488          return NULL;
 489       }
 490    }
 491    return vis;
 492 }
 493
 494 /**
 495  * Makes some sanity checks and fills in the fields of the
 496  * GLvisual object with the given parameters.  If the caller needs
 497  * to set additional fields, he should just probably init the whole GLvisual
 498  * object himself.
 499  * \return GL_TRUE on success, or GL_FALSE on failure.
 500  *
 501  * \sa _mesa_create_visual() above for the parameter description.
 502  */
 503 GLboolean
 504 _mesa_initialize_visual( GLvisual *vis,
 505                          GLboolean rgbFlag,
 506                          GLboolean dbFlag,
 507                          GLboolean stereoFlag,
 508                          GLint redBits,
 509                          GLint greenBits,
 510                          GLint blueBits,
 511                          GLint alphaBits,
 512                          GLint indexBits,
 513                          GLint depthBits,
 514                          GLint stencilBits,
 515                          GLint accumRedBits,
 516                          GLint accumGreenBits,
 517                          GLint accumBlueBits,
 518                          GLint accumAlphaBits,
 519                          GLint numSamples )
 520 {
 521    assert(vis);
 522
 523    if (depthBits < 0 || depthBits > 32) {
 524       return GL_FALSE;
 525    }
 526    if (stencilBits < 0 || stencilBits > STENCIL_BITS) {
 527       return GL_FALSE;
 528    }
 529    if (accumRedBits < 0 || accumRedBits > ACCUM_BITS) {
 530       return GL_FALSE;
 531    }
 532    if (accumGreenBits < 0 || accumGreenBits > ACCUM_BITS) {
 533       return GL_FALSE;
 534    }
 535    if (accumBlueBits < 0 || accumBlueBits > ACCUM_BITS) {
 536       return GL_FALSE;
 537    }
 538    if (accumAlphaBits < 0 || accumAlphaBits > ACCUM_BITS) {
 539       return GL_FALSE;
 540    }
 541
 542    vis->rgbMode          = rgbFlag;
 543    vis->doubleBufferMode = dbFlag;
 544    vis->stereoMode       = stereoFlag;
 545
 546    vis->redBits          = redBits;
 547    vis->greenBits        = greenBits;
 548    vis->blueBits         = blueBits;
 549    vis->alphaBits        = alphaBits;
 550    vis->rgbBits          = redBits + greenBits + blueBits;
 551
 552    vis->indexBits      = indexBits;
 553    vis->depthBits      = depthBits;
 554    vis->stencilBits    = stencilBits;
 555
 556    vis->accumRedBits   = accumRedBits;
 557    vis->accumGreenBits = accumGreenBits;
 558    vis->accumBlueBits  = accumBlueBits;
 559    vis->accumAlphaBits = accumAlphaBits;
 560
 561    vis->haveAccumBuffer   = accumRedBits > 0;
 562    vis->haveDepthBuffer   = depthBits > 0;
 563    vis->haveStencilBuffer = stencilBits > 0;
 564
 565    vis->numAuxBuffers = 0;
 566    vis->level = 0;
 567    vis->pixmapMode = 0;
 568    vis->sampleBuffers = numSamples > 0 ? 1 : 0;
 569    vis->samples = numSamples;
 570
 571    return GL_TRUE;
 572 }
 573
 574
 575 /**
 576  * Destroy a visual and free its memory.
 577  *
 578  * \param vis visual.
 579  *
 580  * Frees the visual structure.
 581  */
 582 void
 583 _mesa_destroy_visual( GLvisual *vis )
 584 {
 585    FREE(vis);
 586 }
 587
 588 /*@}*/
 589
 590
 591 /**********************************************************************/
 592 /** \name Context allocation, initialization, destroying
 593  *
 594  * The purpose of the most initialization functions here is to provide the
 595  * default state values according to the OpenGL specification.
 596  */
 597 /**********************************************************************/
 598 /*@{*/
 599
 600 /**
 601  * One-time initialization mutex lock.
 602  *
 603  * \sa Used by one_time_init().
 604  */
 605 _glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
 606
 607 /**
 608  * Calls all the various one-time-init functions in Mesa.
 609  *
 610  * While holding a global mutex lock, calls several initialization functions,
 611  * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
 612  * defined.
 613  *
 614  * \sa _mesa_init_lists(), _math_init().
 615  */
 616 static void
 617 one_time_init( GLcontext *ctx )
 618 {
 619    static GLboolean alreadyCalled = GL_FALSE;
 620    (void) ctx;
 621    _glthread_LOCK_MUTEX(OneTimeLock);
 622    if (!alreadyCalled) {
 623       GLuint i;
 624
 625       /* do some implementation tests */
 626       assert( sizeof(GLbyte) == 1 );
 627       assert( sizeof(GLubyte) == 1 );
 628       assert( sizeof(GLshort) == 2 );
 629       assert( sizeof(GLushort) == 2 );
 630       assert( sizeof(GLint) == 4 );
 631       assert( sizeof(GLuint) == 4 );
 632
 633       _mesa_init_lists();
 634
 635 #if _HAVE_FULL_GL
 636       _math_init();
 637
 638       for (i = 0; i < 256; i++) {
 639          _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
 640       }
 641 #endif
 642
 643 #ifdef USE_SPARC_ASM
 644       _mesa_init_sparc_glapi_relocs();
 645 #endif
 646       if (_mesa_getenv("MESA_DEBUG")) {
 647          _glapi_noop_enable_warnings(GL_TRUE);
 648 #ifndef GLX_DIRECT_RENDERING
 649          /* libGL from before 2002/06/28 don't have this function.  Someday,
 650           * when newer libGL libs are common, remove the #ifdef test.  This
 651           * only serves to print warnings when calling undefined GL functions.
 652           */
 653          _glapi_set_warning_func( (_glapi_warning_func) _mesa_warning );
 654 #endif
 655       }
 656       else {
 657          _glapi_noop_enable_warnings(GL_FALSE);
 658       }
 659
 660 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
 661       _mesa_debug(ctx, "Mesa DEBUG build %s %s\n", __DATE__, __TIME__);
 662 #endif
 663
 664       alreadyCalled = GL_TRUE;
 665    }
 666    _glthread_UNLOCK_MUTEX(OneTimeLock);
 667 }
 668
 669
 670 /**
 671  * Allocate and initialize a shared context state structure.
 672  * Initializes the display list, texture objects and vertex programs hash
 673  * tables, allocates the texture objects. If it runs out of memory, frees
 674  * everything already allocated before returning NULL.
 675  *
 676  * \return pointer to a gl_shared_state structure on success, or NULL on
 677  * failure.
 678  */
 679 static GLboolean
 680 alloc_shared_state( GLcontext *ctx )
 681 {
 682    struct gl_shared_state *ss = CALLOC_STRUCT(gl_shared_state);
 683    if (!ss)
 684       return GL_FALSE;
 685
 686    ctx->Shared = ss;
 687
 688    _glthread_INIT_MUTEX(ss->Mutex);
 689
 690    ss->DisplayList = _mesa_NewHashTable();
 691    ss->TexObjects = _mesa_NewHashTable();
 692 #if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
 693    ss->Programs = _mesa_NewHashTable();
 694 #endif
 695
 696 #if FEATURE_ARB_vertex_program
 697    ss->DefaultVertexProgram = ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
 698    if (!ss->DefaultVertexProgram)
 699       goto cleanup;
 700 #endif
 701 #if FEATURE_ARB_fragment_program
 702    ss->DefaultFragmentProgram = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
 703    if (!ss->DefaultFragmentProgram)
 704       goto cleanup;
 705 #endif
 706 #if FEATURE_ATI_fragment_shader
 707    ss->DefaultFragmentShader = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_SHADER_ATI, 0);
 708    if (!ss->DefaultFragmentShader)
 709       goto cleanup;
 710 #endif
 711
 712    ss->BufferObjects = _mesa_NewHashTable();
 713
 714    ss->GL2Objects = _mesa_NewHashTable ();
 715
 716    ss->Default1D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D);
 717    if (!ss->Default1D)
 718       goto cleanup;
 719
 720    ss->Default2D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D);
 721    if (!ss->Default2D)
 722       goto cleanup;
 723
 724    ss->Default3D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_3D);
 725    if (!ss->Default3D)
 726       goto cleanup;
 727
 728    ss->DefaultCubeMap = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_CUBE_MAP_ARB);
 729    if (!ss->DefaultCubeMap)
 730       goto cleanup;
 731
 732    ss->DefaultRect = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_RECTANGLE_NV);
 733    if (!ss->DefaultRect)
 734       goto cleanup;
 735
 736    /* Effectively bind the default textures to all texture units */
 737    ss->Default1D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 738    ss->Default2D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 739    ss->Default3D->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 740    ss->DefaultCubeMap->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 741    ss->DefaultRect->RefCount += MAX_TEXTURE_IMAGE_UNITS;
 742
 743 #if FEATURE_EXT_framebuffer_object
 744    ss->FrameBuffers = _mesa_NewHashTable();
 745    if (!ss->FrameBuffers)
 746       goto cleanup;
 747    ss->RenderBuffers = _mesa_NewHashTable();
 748    if (!ss->RenderBuffers)
 749       goto cleanup;
 750 #endif
 751
 752
 753    return GL_TRUE;
 754
 755  cleanup:
 756    /* Ran out of memory at some point.  Free everything and return NULL */
 757    if (ss->DisplayList)
 758       _mesa_DeleteHashTable(ss->DisplayList);
 759    if (ss->TexObjects)
 760       _mesa_DeleteHashTable(ss->TexObjects);
 761 #if FEATURE_NV_vertex_program
 762    if (ss->Programs)
 763       _mesa_DeleteHashTable(ss->Programs);
 764 #endif
 765 #if FEATURE_ARB_vertex_program
 766    if (ss->DefaultVertexProgram)
 767       ctx->Driver.DeleteProgram(ctx, ss->DefaultVertexProgram);
 768 #endif
 769 #if FEATURE_ARB_fragment_program
 770    if (ss->DefaultFragmentProgram)
 771       ctx->Driver.DeleteProgram(ctx, ss->DefaultFragmentProgram);
 772 #endif
 773 #if FEATURE_ATI_fragment_shader
 774    if (ss->DefaultFragmentShader)
 775       ctx->Driver.DeleteProgram(ctx, ss->DefaultFragmentShader);
 776 #endif
 777 #if FEATURE_ARB_vertex_buffer_object
 778    if (ss->BufferObjects)
 779       _mesa_DeleteHashTable(ss->BufferObjects);
 780 #endif
 781
 782    if (ss->GL2Objects)
 783       _mesa_DeleteHashTable (ss->GL2Objects);
 784
 785 #if FEATURE_EXT_framebuffer_object
 786    if (ss->FrameBuffers)
 787       _mesa_DeleteHashTable(ss->FrameBuffers);
 788    if (ss->RenderBuffers)
 789       _mesa_DeleteHashTable(ss->RenderBuffers);
 790 #endif
 791
 792    if (ss->Default1D)
 793       (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D);
 794    if (ss->Default2D)
 795       (*ctx->Driver.DeleteTexture)(ctx, ss->Default2D);
 796    if (ss->Default3D)
 797       (*ctx->Driver.DeleteTexture)(ctx, ss->Default3D);
 798    if (ss->DefaultCubeMap)
 799       (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap);
 800    if (ss->DefaultRect)
 801       (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect);
 802    if (ss)
 803       _mesa_free(ss);
 804    return GL_FALSE;
 805 }
 806
 807 /**
 808  * Deallocate a shared state context and all children structures.
 809  *
 810  * \param ctx GL context.
 811  * \param ss shared state pointer.
 812  *
 813  * Frees the display lists, the texture objects (calling the driver texture
 814  * deletion callback to free its private data) and the vertex programs, as well
 815  * as their hash tables.
 816  *
 817  * \sa alloc_shared_state().
 818  */
 819 static void
 820 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
 821 {
 822    /* Free display lists */
 823    while (1) {
 824       GLuint list = _mesa_HashFirstEntry(ss->DisplayList);
 825       if (list) {
 826          _mesa_destroy_list(ctx, list);
 827       }
 828       else {
 829          break;
 830       }
 831    }
 832    _mesa_DeleteHashTable(ss->DisplayList);
 833
 834    /* Free texture objects */
 835    ASSERT(ctx->Driver.DeleteTexture);
 836    /* the default textures */
 837    (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D);
 838    (*ctx->Driver.DeleteTexture)(ctx, ss->Default2D);
 839    (*ctx->Driver.DeleteTexture)(ctx, ss->Default3D);
 840    (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap);
 841    (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect);
 842    /* all other textures */
 843    while (1) {
 844       GLuint texName = _mesa_HashFirstEntry(ss->TexObjects);
 845       if (texName) {
 846          struct gl_texture_object *texObj = (struct gl_texture_object *)
 847             _mesa_HashLookup(ss->TexObjects, texName);
 848          ASSERT(texObj);
 849          (*ctx->Driver.DeleteTexture)(ctx, texObj);
 850          _mesa_HashRemove(ss->TexObjects, texName);
 851       }
 852       else {
 853          break;
 854       }
 855    }
 856    _mesa_DeleteHashTable(ss->TexObjects);
 857
 858 #if FEATURE_NV_vertex_program
 859    /* Free vertex programs */
 860    while (1) {
 861       GLuint prog = _mesa_HashFirstEntry(ss->Programs);
 862       if (prog) {
 863          struct program *p = (struct program *) _mesa_HashLookup(ss->Programs,
 864                                                                  prog);
 865          ASSERT(p);
 866          ctx->Driver.DeleteProgram(ctx, p);
 867          _mesa_HashRemove(ss->Programs, prog);
 868       }
 869       else {
 870          break;
 871       }
 872    }
 873    _mesa_DeleteHashTable(ss->Programs);
 874 #endif
 875 #if FEATURE_ARB_vertex_program
 876    _mesa_delete_program(ctx, ss->DefaultVertexProgram);
 877 #endif
 878 #if FEATURE_ARB_fragment_program
 879    _mesa_delete_program(ctx, ss->DefaultFragmentProgram);
 880 #endif
 881 #if FEATURE_ATI_fragment_shader
 882    _mesa_delete_program(ctx, ss->DefaultFragmentShader);
 883 #endif
 884
 885 #if FEATURE_ARB_vertex_buffer_object
 886    _mesa_DeleteHashTable(ss->BufferObjects);
 887 #endif
 888
 889    _mesa_DeleteHashTable (ss->GL2Objects);
 890
 891 #if FEATURE_EXT_framebuffer_object
 892    _mesa_DeleteHashTable(ss->FrameBuffers);
 893    _mesa_DeleteHashTable(ss->RenderBuffers);
 894 #endif
 895
 896    _glthread_DESTROY_MUTEX(ss->Mutex);
 897
 898    FREE(ss);
 899 }
 900
 901
 902 /**
 903  * Initialize fields of gl_current_attrib (aka ctx->Current.*)
 904  */
 905 static void
 906 _mesa_init_current( GLcontext *ctx )
 907 {
 908    GLuint i;
 909
 910    /* Current group */
 911    for (i = 0; i < VERT_ATTRIB_MAX; i++) {
 912       ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
 913    }
 914    /* special cases: */
 915    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 1.0 );
 916    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
 917    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
 918    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
 919    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_FOG], 0.0, 0.0, 0.0, 0.0 );
 920
 921    ctx->Current.Index = 1;
 922    ctx->Current.EdgeFlag = GL_TRUE;
 923 }
 924
 925
 926 /**
 927  * Initialize fields of gl_constants (aka ctx->Const.*).
 928  * Use defaults from config.h.  The device drivers will often override
 929  * some of these values (such as number of texture units).
 930  */
 931 static void
 932 _mesa_init_constants( GLcontext *ctx )
 933 {
 934    assert(ctx);
 935
 936    assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
 937    assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
 938
 939    /* Constants, may be overriden (usually only reduced) by device drivers */
 940    ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
 941    ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
 942    ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
 943    ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
 944    ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
 945    ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
 946    ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 947    ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
 948    ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
 949    ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
 950    ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
 951    ctx->Const.MinPointSize = MIN_POINT_SIZE;
 952    ctx->Const.MaxPointSize = MAX_POINT_SIZE;
 953    ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
 954    ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
 955    ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
 956    ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
 957    ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
 958    ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
 959    ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
 960    ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
 961    ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
 962    ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
 963    ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
 964    ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
 965    ctx->Const.MaxLights = MAX_LIGHTS;
 966    ctx->Const.MaxShininess = 128.0;
 967    ctx->Const.MaxSpotExponent = 128.0;
 968    ctx->Const.MaxViewportWidth = MAX_WIDTH;
 969    ctx->Const.MaxViewportHeight = MAX_HEIGHT;
 970 #if FEATURE_ARB_vertex_program
 971    ctx->Const.MaxVertexProgramInstructions = MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS;
 972    ctx->Const.MaxVertexProgramAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
 973    ctx->Const.MaxVertexProgramTemps = MAX_NV_VERTEX_PROGRAM_TEMPS;
 974    ctx->Const.MaxVertexProgramLocalParams = MAX_NV_VERTEX_PROGRAM_PARAMS;
 975    ctx->Const.MaxVertexProgramEnvParams = MAX_NV_VERTEX_PROGRAM_PARAMS;/*XXX*/
 976    ctx->Const.MaxVertexProgramAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
 977 #endif
 978 #if FEATURE_ARB_fragment_program
 979    ctx->Const.MaxFragmentProgramInstructions = MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS;
 980    ctx->Const.MaxFragmentProgramAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
 981    ctx->Const.MaxFragmentProgramTemps = MAX_NV_FRAGMENT_PROGRAM_TEMPS;
 982    ctx->Const.MaxFragmentProgramLocalParams = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
 983    ctx->Const.MaxFragmentProgramEnvParams = MAX_NV_FRAGMENT_PROGRAM_PARAMS;/*XXX*/
 984    ctx->Const.MaxFragmentProgramAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
 985    ctx->Const.MaxFragmentProgramAluInstructions = MAX_FRAGMENT_PROGRAM_ALU_INSTRUCTIONS;
 986    ctx->Const.MaxFragmentProgramTexInstructions = MAX_FRAGMENT_PROGRAM_TEX_INSTRUCTIONS;
 987    ctx->Const.MaxFragmentProgramTexIndirections = MAX_FRAGMENT_PROGRAM_TEX_INDIRECTIONS;
 988 #endif
 989
 990    ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
 991    ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
 992
 993    /* If we're running in the X server, do bounds checking to prevent
 994     * segfaults and server crashes!
 995     */
 996 #if defined(XFree86LOADER) && defined(IN_MODULE)
 997    ctx->Const.CheckArrayBounds = GL_TRUE;
 998 #else
 999    ctx->Const.CheckArrayBounds = GL_FALSE;
1000 #endif
1001
1002    ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
1003
1004    /* GL_OES_read_format */
1005    ctx->Const.ColorReadFormat = GL_RGBA;
1006    ctx->Const.ColorReadType = GL_UNSIGNED_BYTE;
1007
1008 #if FEATURE_EXT_framebuffer_object
1009    ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
1010    ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
1011 #endif
1012
1013    /* sanity checks */
1014    ASSERT(ctx->Const.MaxTextureUnits == MAX2(ctx->Const.MaxTextureImageUnits, ctx->Const.MaxTextureCoordUnits));
1015 }
1016
1017
1018 /**
1019  * Initialize the attribute groups in a GL context.
1020  *
1021  * \param ctx GL context.
1022  *
1023  * Initializes all the attributes, calling the respective <tt>init*</tt>
1024  * functions for the more complex data structures.
1025  */
1026 static GLboolean
1027 init_attrib_groups( GLcontext *ctx )
1028 {
1029    assert(ctx);
1030
1031    /* Constants */
1032    _mesa_init_constants( ctx );
1033
1034    /* Extensions */
1035    _mesa_init_extensions( ctx );
1036
1037    /* Attribute Groups */
1038    _mesa_init_accum( ctx );
1039    _mesa_init_attrib( ctx );
1040    _mesa_init_buffer_objects( ctx );
1041    _mesa_init_color( ctx );
1042    _mesa_init_colortables( ctx );
1043    _mesa_init_current( ctx );
1044    _mesa_init_depth( ctx );
1045    _mesa_init_debug( ctx );
1046    _mesa_init_display_list( ctx );
1047    _mesa_init_eval( ctx );
1048    _mesa_init_feedback( ctx );
1049    _mesa_init_fog( ctx );
1050    _mesa_init_histogram( ctx );
1051    _mesa_init_hint( ctx );
1052    _mesa_init_line( ctx );
1053    _mesa_init_lighting( ctx );
1054    _mesa_init_matrix( ctx );
1055    _mesa_init_multisample( ctx );
1056    _mesa_init_occlude( ctx );
1057    _mesa_init_pixel( ctx );
1058    _mesa_init_point( ctx );
1059    _mesa_init_polygon( ctx );
1060    _mesa_init_program( ctx );
1061    _mesa_init_rastpos( ctx );
1062    _mesa_init_scissor( ctx );
1063    _mesa_init_shaderobjects (ctx);
1064    _mesa_init_stencil( ctx );
1065    _mesa_init_transform( ctx );
1066    _mesa_init_varray( ctx );
1067    _mesa_init_viewport( ctx );
1068
1069    if (!_mesa_init_texture( ctx ))
1070       return GL_FALSE;
1071
1072    _mesa_init_texture_s3tc( ctx );
1073    _mesa_init_texture_fxt1( ctx );
1074
1075    /* Miscellaneous */
1076    ctx->NewState = _NEW_ALL;
1077    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1078    ctx->_Facing = 0;
1079 #if CHAN_TYPE == GL_FLOAT
1080    ctx->ClampFragmentColors = GL_FALSE; /* XXX temporary */
1081 #else
1082    ctx->ClampFragmentColors = GL_TRUE;
1083 #endif
1084    ctx->ClampVertexColors = GL_TRUE;
1085
1086    return GL_TRUE;
1087 }
1088
1089
1090 /**
1091  * If the DRI libGL.so library is old, it may not have the entrypoints for
1092  * some recent OpenGL extensions.  Dynamically add them now.
1093  * If we're building stand-alone Mesa where libGL.so has both the dispatcher
1094  * and driver code, this won't be an issue (and calling this function won't
1095  * do any harm).
1096  */
1097 static void
1098 add_newer_entrypoints(void)
1099 {
1100    unsigned i;
1101    static const struct {
1102       const char * const name;
1103       unsigned offset;
1104    }
1105    newer_entrypoints[] = {
1106       /* GL_ARB_window_pos aliases with GL_MESA_window_pos */
1107       { "glWindowPos2dARB", 513 },
1108       { "glWindowPos2dvARB", 514 },
1109       { "glWindowPos2fARB", 515 },
1110       { "glWindowPos2fvARB", 516 },
1111       { "glWindowPos2iARB", 517 },
1112       { "glWindowPos2ivARB", 518 },
1113       { "glWindowPos2sARB", 519 },
1114       { "glWindowPos2svARB", 520 },
1115       { "glWindowPos3dARB", 521 },
1116       { "glWindowPos3dvARB", 522 },
1117       { "glWindowPos3fARB", 523 },
1118       { "glWindowPos3fvARB", 524 },
1119       { "glWindowPos3iARB", 525 },
1120       { "glWindowPos3ivARB", 526 },
1121       { "glWindowPos3sARB", 527 },
1122       { "glWindowPos3svARB", 528 },
1123 #if FEATURE_NV_vertex_program
1124       { "glAreProgramsResidentNV", 578 },
1125       { "glBindProgramNV", 579 },
1126       { "glDeleteProgramsNV", 580 },
1127       { "glExecuteProgramNV", 581 },
1128       { "glGenProgramsNV", 582 },
1129       { "glGetProgramParameterdvNV", 583 },
1130       { "glGetProgramParameterfvNV", 584 },
1131       { "glGetProgramivNV", 585 },
1132       { "glGetProgramStringNV", 586 },
1133       { "glGetTrackMatrixivNV", 587 },
1134       { "glGetVertexAttribdvNV", 588 },
1135       { "glGetVertexAttribfvNV", 589 },
1136       { "glGetVertexAttribivNV", 590 },
1137       { "glGetVertexAttribPointervNV", 591 },
1138       { "glIsProgramNV", 592 },
1139       { "glLoadProgramNV", 593 },
1140       { "glProgramParameter4dNV", 594 },
1141       { "glProgramParameter4dvNV", 595 },
1142       { "glProgramParameter4fNV", 596 },
1143       { "glProgramParameter4fvNV", 597 },
1144       { "glProgramParameters4dvNV", 598 },
1145       { "glProgramParameters4fvNV", 599 },
1146       { "glRequestResidentProgramsNV", 600 },
1147       { "glTrackMatrixNV", 601 },
1148       { "glVertexAttribPointerNV", 602 },
1149       { "glVertexAttrib1dNV", 603 },
1150       { "glVertexAttrib1dvNV", 604 },
1151       { "glVertexAttrib1fNV", 605 },
1152       { "glVertexAttrib1fvNV", 606 },
1153       { "glVertexAttrib1sNV", 607 },
1154       { "glVertexAttrib1svNV", 608 },
1155       { "glVertexAttrib2dNV", 609 },
1156       { "glVertexAttrib2dvNV", 610 },
1157       { "glVertexAttrib2fNV", 611 },
1158       { "glVertexAttrib2fvNV", 612 },
1159       { "glVertexAttrib2sNV", 613 },
1160       { "glVertexAttrib2svNV", 614 },
1161       { "glVertexAttrib3dNV", 615 },
1162       { "glVertexAttrib3dvNV", 616 },
1163       { "glVertexAttrib3fNV", 617 },
1164       { "glVertexAttrib3fvNV", 618 },
1165       { "glVertexAttrib3sNV", 619 },
1166       { "glVertexAttrib3svNV", 620 },
1167       { "glVertexAttrib4dNV", 621 },
1168       { "glVertexAttrib4dvNV", 622 },
1169       { "glVertexAttrib4fNV", 623 },
1170       { "glVertexAttrib4fvNV", 624 },
1171       { "glVertexAttrib4sNV", 625 },
1172       { "glVertexAttrib4svNV", 626 },
1173       { "glVertexAttrib4ubNV", 627 },
1174       { "glVertexAttrib4ubvNV", 628 },
1175       { "glVertexAttribs1dvNV", 629 },
1176       { "glVertexAttribs1fvNV", 630 },
1177       { "glVertexAttribs1svNV", 631 },
1178       { "glVertexAttribs2dvNV", 632 },
1179       { "glVertexAttribs2fvNV", 633 },
1180       { "glVertexAttribs2svNV", 634 },
1181       { "glVertexAttribs3dvNV", 635 },
1182       { "glVertexAttribs3fvNV", 636 },
1183       { "glVertexAttribs3svNV", 637 },
1184       { "glVertexAttribs4dvNV", 638 },
1185       { "glVertexAttribs4fvNV", 639 },
1186       { "glVertexAttribs4svNV", 640 },
1187       { "glVertexAttribs4ubvNV", 641 },
1188 #endif
1189       { "glPointParameteriNV", 642 },
1190       { "glPointParameterivNV", 643 },
1191       { "glMultiDrawArraysEXT", 644 },
1192       { "glMultiDrawElementsEXT", 645 },
1193       { "glMultiDrawArraysSUN", _gloffset_MultiDrawArraysEXT  },
1194       { "glMultiDrawElementsSUN", _gloffset_MultiDrawElementsEXT  },
1195       { "glActiveStencilFaceEXT", 646 },
1196 #if FEATURE_NV_fence
1197       { "glDeleteFencesNV", 647 },
1198       { "glGenFencesNV", 648 },
1199       { "glIsFenceNV", 649 },
1200       { "glTestFenceNV", 650 },
1201       { "glGetFenceivNV", 651 },
1202       { "glFinishFenceNV", 652 },
1203       { "glSetFenceNV", 653 },
1204 #endif
1205 #if FEATURE_NV_fragment_program
1206       { "glProgramNamedParameter4fNV", 682 },
1207       { "glProgramNamedParameter4dNV", 683 },
1208       { "glProgramNamedParameter4fvNV", 683 },
1209       { "glProgramNamedParameter4dvNV", 684 },
1210       { "glGetProgramNamedParameterfvNV", 685 },
1211       { "glGetProgramNamedParameterdvNV", 686 },
1212 #endif
1213 #if FEATURE_ARB_vertex_program
1214       { "glVertexAttrib1sARB", _gloffset_VertexAttrib1sNV },
1215       { "glVertexAttrib1fARB", _gloffset_VertexAttrib1fNV },
1216       { "glVertexAttrib1dARB", _gloffset_VertexAttrib1dNV },
1217       { "glVertexAttrib2sARB", _gloffset_VertexAttrib2sNV },
1218       { "glVertexAttrib2fARB", _gloffset_VertexAttrib2fNV },
1219       { "glVertexAttrib2dARB", _gloffset_VertexAttrib2dNV },
1220       { "glVertexAttrib3sARB", _gloffset_VertexAttrib3sNV },
1221       { "glVertexAttrib3fARB", _gloffset_VertexAttrib3fNV },
1222       { "glVertexAttrib3dARB", _gloffset_VertexAttrib3dNV },
1223       { "glVertexAttrib4sARB", _gloffset_VertexAttrib4sNV },
1224       { "glVertexAttrib4fARB", _gloffset_VertexAttrib4fNV },
1225       { "glVertexAttrib4dARB", _gloffset_VertexAttrib4dNV },
1226       { "glVertexAttrib4NubARB", _gloffset_VertexAttrib4ubNV },
1227       { "glVertexAttrib1svARB", _gloffset_VertexAttrib1svNV },
1228       { "glVertexAttrib1fvARB", _gloffset_VertexAttrib1fvNV },
1229       { "glVertexAttrib1dvARB", _gloffset_VertexAttrib1dvNV },
1230       { "glVertexAttrib2svARB", _gloffset_VertexAttrib2svNV },
1231       { "glVertexAttrib2fvARB", _gloffset_VertexAttrib2fvNV },
1232       { "glVertexAttrib2dvARB", _gloffset_VertexAttrib2dvNV },
1233       { "glVertexAttrib3svARB", _gloffset_VertexAttrib3svNV },
1234       { "glVertexAttrib3fvARB", _gloffset_VertexAttrib3fvNV },
1235       { "glVertexAttrib3dvARB", _gloffset_VertexAttrib3dvNV },
1236       { "glVertexAttrib4bvARB", _gloffset_VertexAttrib4bvARB },
1237       { "glVertexAttrib4svARB", _gloffset_VertexAttrib4svNV },
1238       { "glVertexAttrib4ivARB", _gloffset_VertexAttrib4ivARB },
1239       { "glVertexAttrib4ubvARB", _gloffset_VertexAttrib4ubvARB },
1240       { "glVertexAttrib4usvARB", _gloffset_VertexAttrib4usvARB },
1241       { "glVertexAttrib4uivARB", _gloffset_VertexAttrib4uivARB },
1242       { "glVertexAttrib4fvARB", _gloffset_VertexAttrib4fvNV },
1243       { "glVertexAttrib4dvARB", _gloffset_VertexAttrib4dvNV },
1244       { "glVertexAttrib4NbvARB", _gloffset_VertexAttrib4NbvARB },
1245       { "glVertexAttrib4NsvARB", _gloffset_VertexAttrib4NsvARB },
1246       { "glVertexAttrib4NivARB", _gloffset_VertexAttrib4NivARB },
1247       { "glVertexAttrib4NubvARB", _gloffset_VertexAttrib4ubvNV },
1248       { "glVertexAttrib4NusvARB", _gloffset_VertexAttrib4NusvARB },
1249       { "glVertexAttrib4NuivARB", _gloffset_VertexAttrib4NuivARB },
1250       { "glVertexAttribPointerARB", _gloffset_VertexAttribPointerARB },
1251       { "glEnableVertexAttribArrayARB", _gloffset_EnableVertexAttribArrayARB },
1252       { "glDisableVertexAttribArrayARB", _gloffset_DisableVertexAttribArrayARB },
1253       { "glProgramStringARB", _gloffset_ProgramStringARB },
1254       { "glBindProgramARB", _gloffset_BindProgramNV },
1255       { "glDeleteProgramsARB", _gloffset_DeleteProgramsNV },
1256       { "glGenProgramsARB", _gloffset_GenProgramsNV },
1257       { "glIsProgramARB", _gloffset_IsProgramNV },
1258       { "glProgramEnvParameter4dARB", _gloffset_ProgramEnvParameter4dARB },
1259       { "glProgramEnvParameter4dvARB", _gloffset_ProgramEnvParameter4dvARB },
1260       { "glProgramEnvParameter4fARB", _gloffset_ProgramEnvParameter4fARB },
1261       { "glProgramEnvParameter4fvARB", _gloffset_ProgramEnvParameter4fvARB },
1262       { "glProgramLocalParameter4dARB", _gloffset_ProgramLocalParameter4dARB },
1263       { "glProgramLocalParameter4dvARB", _gloffset_ProgramLocalParameter4dvARB },
1264       { "glProgramLocalParameter4fARB", _gloffset_ProgramLocalParameter4fARB },
1265       { "glProgramLocalParameter4fvARB", _gloffset_ProgramLocalParameter4fvARB },
1266       { "glGetProgramEnvParameterdvARB", _gloffset_GetProgramEnvParameterdvARB },
1267       { "glGetProgramEnvParameterfvARB", _gloffset_GetProgramEnvParameterfvARB },
1268       { "glGetProgramLocalParameterdvARB", _gloffset_GetProgramLocalParameterdvARB },
1269       { "glGetProgramLocalParameterfvARB", _gloffset_GetProgramLocalParameterfvARB },
1270       { "glGetProgramivARB", _gloffset_GetProgramivARB },
1271       { "glGetProgramStringARB", _gloffset_GetProgramStringARB },
1272       { "glGetVertexAttribdvARB", _gloffset_GetVertexAttribdvNV },
1273       { "glGetVertexAttribfvARB", _gloffset_GetVertexAttribfvNV },
1274       { "glGetVertexAttribivARB", _gloffset_GetVertexAttribivNV },
1275       { "glGetVertexAttribPointervARB", _gloffset_GetVertexAttribPointervNV },
1276 #endif
1277       { "glMultiModeDrawArraysIBM", _gloffset_MultiModeDrawArraysIBM },
1278       { "glMultiModeDrawElementsIBM", _gloffset_MultiModeDrawElementsIBM },
1279       /* GL_EXT_stencil_two_side */
1280       { "glActiveStencilFaceEXT", _gloffset_ActiveStencilFaceEXT },
1281       /* GL_ARB_draw_buffers */
1282       { "glDrawBuffersARB", _gloffset_DrawBuffersARB },
1283 #if FEATURE_ATI_fragment_shader
1284       { "glGenFragmentShadersATI", _gloffset_GenFragmentShadersATI },
1285       { "glBindFragmentShaderATI", _gloffset_BindFragmentShaderATI },
1286       { "glDeleteFragmentShaderATI", _gloffset_DeleteFragmentShaderATI },
1287       { "glBeginFragmentShaderATI", _gloffset_BeginFragmentShaderATI },
1288       { "glEndFragmentShaderATI", _gloffset_EndFragmentShaderATI },
1289       { "glPassTexCoordATI", _gloffset_PassTexCoordATI },
1290       { "glSampleMapATI", _gloffset_SampleMapATI },
1291       { "glColorFragmentOp1ATI", _gloffset_ColorFragmentOp1ATI },
1292       { "glColorFragmentOp2ATI", _gloffset_ColorFragmentOp2ATI },
1293       { "glColorFragmentOp3ATI", _gloffset_ColorFragmentOp3ATI },
1294       { "glAlphaFragmentOp1ATI", _gloffset_AlphaFragmentOp1ATI },
1295       { "glAlphaFragmentOp2ATI", _gloffset_AlphaFragmentOp2ATI },
1296       { "glAlphaFragmentOp3ATI", _gloffset_AlphaFragmentOp3ATI },
1297       { "glSetFragmentShaderConstantATI", _gloffset_SetFragmentShaderConstantATI },
1298 #endif
1299    };
1300
1301    for (i = 0; i < Elements(newer_entrypoints); i++ ) {
1302       _glapi_add_entrypoint( newer_entrypoints[i].name,
1303                              newer_entrypoints[i].offset );
1304    }
1305 }
1306
1307
1308 /**
1309  * This is the default function we plug into all dispatch table slots
1310  * This helps prevents a segfault when someone calls a GL function without
1311  * first checking if the extension's supported.
1312  */
1313 static int
1314 generic_nop(void)
1315 {
1316    _mesa_problem(NULL, "User called no-op dispatch function (an unsupported extension function?)");
1317    return 0;
1318 }
1319
1320
1321 /**
1322  * Allocate and initialize a new dispatch table.
1323  */
1324 static struct _glapi_table *
1325 alloc_dispatch_table(void)
1326 {
1327    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1328     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
1329     * Mesa we do this to accomodate different versions of libGL and various
1330     * DRI drivers.
1331     */
1332    GLint numEntries = MAX2(_glapi_get_dispatch_table_size(),
1333                            sizeof(struct _glapi_table) / sizeof(_glapi_proc));
1334    struct _glapi_table *table =
1335       (struct _glapi_table *) _mesa_malloc(numEntries * sizeof(_glapi_proc));
1336    if (table) {
1337       _glapi_proc *entry = (_glapi_proc *) table;
1338       GLint i;
1339       for (i = 0; i < numEntries; i++) {
1340          entry[i] = (_glapi_proc) generic_nop;
1341       }
1342    }
1343    return table;
1344 }
1345
1346
1347 /**
1348  * Initialize a GLcontext struct (rendering context).
1349  *
1350  * This includes allocating all the other structs and arrays which hang off of
1351  * the context by pointers.
1352  * Note that the driver needs to pass in its dd_function_table here since
1353  * we need to at least call driverFunctions->NewTextureObject to create the
1354  * default texture objects.
1355  *
1356  * Called by _mesa_create_context().
1357  *
1358  * Performs the imports and exports callback tables initialization, and
1359  * miscellaneous one-time initializations. If no shared context is supplied one
1360  * is allocated, and increase its reference count.  Setups the GL API dispatch
1361  * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
1362  * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1363  * for debug flags.
1364  *
1365  * \param ctx the context to initialize
1366  * \param visual describes the visual attributes for this context
1367  * \param share_list points to context to share textures, display lists,
1368  *        etc with, or NULL
1369  * \param driverFunctions table of device driver functions for this context
1370  *        to use
1371  * \param driverContext pointer to driver-specific context data
1372  */
1373 GLboolean
1374 _mesa_initialize_context( GLcontext *ctx,
1375                           const GLvisual *visual,
1376                           GLcontext *share_list,
1377                           const struct dd_function_table *driverFunctions,
1378                           void *driverContext )
1379 {
1380    ASSERT(driverContext);
1381    assert(driverFunctions->NewTextureObject);
1382    assert(driverFunctions->FreeTexImageData);
1383
1384    /* If the driver wants core Mesa to use special imports, it'll have to
1385     * override these defaults.
1386     */
1387    _mesa_init_default_imports( &(ctx->imports), driverContext );
1388
1389    /* initialize the exports (Mesa functions called by the window system) */
1390    _mesa_init_default_exports( &(ctx->exports) );
1391
1392    /* misc one-time initializations */
1393    one_time_init(ctx);
1394
1395    ctx->Visual = *visual;
1396    ctx->DrawBuffer = NULL;
1397    ctx->ReadBuffer = NULL;
1398    ctx->WinSysDrawBuffer = NULL;
1399    ctx->WinSysReadBuffer = NULL;
1400
1401    /* Plug in driver functions and context pointer here.
1402     * This is important because when we call alloc_shared_state() below
1403     * we'll call ctx->Driver.NewTextureObject() to create the default
1404     * textures.
1405     */
1406    ctx->Driver = *driverFunctions;
1407    ctx->DriverCtx = driverContext;
1408
1409    if (share_list) {
1410       /* share state with another context */
1411       ctx->Shared = share_list->Shared;
1412    }
1413    else {
1414       /* allocate new, unshared state */
1415       if (!alloc_shared_state( ctx )) {
1416          return GL_FALSE;
1417       }
1418    }
1419    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1420    ctx->Shared->RefCount++;
1421    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1422
1423    if (!init_attrib_groups( ctx )) {
1424       free_shared_state(ctx, ctx->Shared);
1425       return GL_FALSE;
1426    }
1427
1428    /* libGL ABI coordination */
1429    add_newer_entrypoints();
1430
1431    /* setup the API dispatch tables */
1432    ctx->Exec = alloc_dispatch_table();
1433    ctx->Save = alloc_dispatch_table();
1434    if (!ctx->Exec || !ctx->Save) {
1435       free_shared_state(ctx, ctx->Shared);
1436       if (ctx->Exec)
1437          _mesa_free(ctx->Exec);
1438    }
1439    _mesa_init_exec_table(ctx->Exec);
1440    ctx->CurrentDispatch = ctx->Exec;
1441 #if _HAVE_FULL_GL
1442    _mesa_init_dlist_table(ctx->Save);
1443    _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
1444    /* Neutral tnl module stuff */
1445    _mesa_init_exec_vtxfmt( ctx );
1446    ctx->TnlModule.Current = NULL;
1447    ctx->TnlModule.SwapCount = 0;
1448 #endif
1449
1450    ctx->_MaintainTexEnvProgram = (_mesa_getenv("MESA_TEX_PROG") != NULL);
1451    ctx->_MaintainTnlProgram = (_mesa_getenv("MESA_TNL_PROG") != NULL);
1452
1453    return GL_TRUE;
1454 }
1455
1456
1457 /**
1458  * Allocate and initialize a GLcontext structure.
1459  * Note that the driver needs to pass in its dd_function_table here since
1460  * we need to at least call driverFunctions->NewTextureObject to initialize
1461  * the rendering context.
1462  *
1463  * \param visual a GLvisual pointer (we copy the struct contents)
1464  * \param share_list another context to share display lists with or NULL
1465  * \param driverFunctions points to the dd_function_table into which the
1466  *        driver has plugged in all its special functions.
1467  * \param driverCtx points to the device driver's private context state
1468  *
1469  * \return pointer to a new __GLcontextRec or NULL if error.
1470  */
1471 GLcontext *
1472 _mesa_create_context( const GLvisual *visual,
1473                       GLcontext *share_list,
1474                       const struct dd_function_table *driverFunctions,
1475                       void *driverContext )
1476
1477 {
1478    GLcontext *ctx;
1479
1480    ASSERT(visual);
1481    ASSERT(driverContext);
1482
1483    ctx = (GLcontext *) _mesa_calloc(sizeof(GLcontext));
1484    if (!ctx)
1485       return NULL;
1486
1487    if (_mesa_initialize_context(ctx, visual, share_list,
1488                                 driverFunctions, driverContext)) {
1489       return ctx;
1490    }
1491    else {
1492       _mesa_free(ctx);
1493       return NULL;
1494    }
1495 }
1496
1497
1498 /**
1499  * Free the data associated with the given context.
1500  *
1501  * But doesn't free the GLcontext struct itself.
1502  *
1503  * \sa _mesa_initialize_context() and init_attrib_groups().
1504  */
1505 void
1506 _mesa_free_context_data( GLcontext *ctx )
1507 {
1508    /* if we're destroying the current context, unbind it first */
1509    if (ctx == _mesa_get_current_context()) {
1510       _mesa_make_current(NULL, NULL, NULL);
1511    }
1512
1513    _mesa_free_lighting_data( ctx );
1514    _mesa_free_eval_data( ctx );
1515    _mesa_free_texture_data( ctx );
1516    _mesa_free_matrix_data( ctx );
1517    _mesa_free_viewport_data( ctx );
1518    _mesa_free_colortables_data( ctx );
1519    _mesa_free_program_data(ctx);
1520    _mesa_free_occlude_data(ctx);
1521
1522 #if FEATURE_ARB_vertex_buffer_object
1523    _mesa_delete_buffer_object(ctx, ctx->Array.NullBufferObj);
1524 #endif
1525
1526    /* free dispatch tables */
1527    _mesa_free(ctx->Exec);
1528    _mesa_free(ctx->Save);
1529
1530    /* Shared context state (display lists, textures, etc) */
1531    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1532    ctx->Shared->RefCount--;
1533    assert(ctx->Shared->RefCount >= 0);
1534    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1535    if (ctx->Shared->RefCount == 0) {
1536       /* free shared state */
1537       free_shared_state( ctx, ctx->Shared );
1538    }
1539
1540    if (ctx->Extensions.String)
1541       FREE((void *) ctx->Extensions.String);
1542 }
1543
1544
1545 /**
1546  * Destroy a GLcontext structure.
1547  *
1548  * \param ctx GL context.
1549  *
1550  * Calls _mesa_free_context_data() and frees the GLcontext structure itself.
1551  */
1552 void
1553 _mesa_destroy_context( GLcontext *ctx )
1554 {
1555    if (ctx) {
1556       _mesa_free_context_data(ctx);
1557       FREE( (void *) ctx );
1558    }
1559 }
1560
1561
1562 #if _HAVE_FULL_GL
1563 /**
1564  * Copy attribute groups from one context to another.
1565  *
1566  * \param src source context
1567  * \param dst destination context
1568  * \param mask bitwise OR of GL_*_BIT flags
1569  *
1570  * According to the bits specified in \p mask, copies the corresponding
1571  * attributes from \p src into \p dst.  For many of the attributes a simple \c
1572  * memcpy is not enough due to the existence of internal pointers in their data
1573  * structures.
1574  */
1575 void
1576 _mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1577 {
1578    if (mask & GL_ACCUM_BUFFER_BIT) {
1579       /* OK to memcpy */
1580       dst->Accum = src->Accum;
1581    }
1582    if (mask & GL_COLOR_BUFFER_BIT) {
1583       /* OK to memcpy */
1584       dst->Color = src->Color;
1585    }
1586    if (mask & GL_CURRENT_BIT) {
1587       /* OK to memcpy */
1588       dst->Current = src->Current;
1589    }
1590    if (mask & GL_DEPTH_BUFFER_BIT) {
1591       /* OK to memcpy */
1592       dst->Depth = src->Depth;
1593    }
1594    if (mask & GL_ENABLE_BIT) {
1595       /* no op */
1596    }
1597    if (mask & GL_EVAL_BIT) {
1598       /* OK to memcpy */
1599       dst->Eval = src->Eval;
1600    }
1601    if (mask & GL_FOG_BIT) {
1602       /* OK to memcpy */
1603       dst->Fog = src->Fog;
1604    }
1605    if (mask & GL_HINT_BIT) {
1606       /* OK to memcpy */
1607       dst->Hint = src->Hint;
1608    }
1609    if (mask & GL_LIGHTING_BIT) {
1610       GLuint i;
1611       /* begin with memcpy */
1612       MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light) );
1613       /* fixup linked lists to prevent pointer insanity */
1614       make_empty_list( &(dst->Light.EnabledList) );
1615       for (i = 0; i < MAX_LIGHTS; i++) {
1616          if (dst->Light.Light[i].Enabled) {
1617             insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
1618          }
1619       }
1620    }
1621    if (mask & GL_LINE_BIT) {
1622       /* OK to memcpy */
1623       dst->Line = src->Line;
1624    }
1625    if (mask & GL_LIST_BIT) {
1626       /* OK to memcpy */
1627       dst->List = src->List;
1628    }
1629    if (mask & GL_PIXEL_MODE_BIT) {
1630       /* OK to memcpy */
1631       dst->Pixel = src->Pixel;
1632    }
1633    if (mask & GL_POINT_BIT) {
1634       /* OK to memcpy */
1635       dst->Point = src->Point;
1636    }
1637    if (mask & GL_POLYGON_BIT) {
1638       /* OK to memcpy */
1639       dst->Polygon = src->Polygon;
1640    }
1641    if (mask & GL_POLYGON_STIPPLE_BIT) {
1642       /* Use loop instead of MEMCPY due to problem with Portland Group's
1643        * C compiler.  Reported by John Stone.
1644        */
1645       GLuint i;
1646       for (i = 0; i < 32; i++) {
1647          dst->PolygonStipple[i] = src->PolygonStipple[i];
1648       }
1649    }
1650    if (mask & GL_SCISSOR_BIT) {
1651       /* OK to memcpy */
1652       dst->Scissor = src->Scissor;
1653    }
1654    if (mask & GL_STENCIL_BUFFER_BIT) {
1655       /* OK to memcpy */
1656       dst->Stencil = src->Stencil;
1657    }
1658    if (mask & GL_TEXTURE_BIT) {
1659       /* Cannot memcpy because of pointers */
1660       _mesa_copy_texture_state(src, dst);
1661    }
1662    if (mask & GL_TRANSFORM_BIT) {
1663       /* OK to memcpy */
1664       dst->Transform = src->Transform;
1665    }
1666    if (mask & GL_VIEWPORT_BIT) {
1667       /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
1668       dst->Viewport.X = src->Viewport.X;
1669       dst->Viewport.Y = src->Viewport.Y;
1670       dst->Viewport.Width = src->Viewport.Width;
1671       dst->Viewport.Height = src->Viewport.Height;
1672       dst->Viewport.Near = src->Viewport.Near;
1673       dst->Viewport.Far = src->Viewport.Far;
1674       _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
1675    }
1676
1677    /* XXX FIXME:  Call callbacks?
1678     */
1679    dst->NewState = _NEW_ALL;
1680 }
1681 #endif
1682
1683
1684 /**
1685  * Check if the given context can render into the given framebuffer
1686  * by checking visual attributes.
1687  * \return GL_TRUE if compatible, GL_FALSE otherwise.
1688  */
1689 static GLboolean
1690 check_compatible(const GLcontext *ctx, const GLframebuffer *buffer)
1691 {
1692    const GLvisual *ctxvis = &ctx->Visual;
1693    const GLvisual *bufvis = &buffer->Visual;
1694
1695    if (ctxvis == bufvis)
1696       return GL_TRUE;
1697
1698    if (ctxvis->rgbMode != bufvis->rgbMode)
1699       return GL_FALSE;
1700    if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
1701       return GL_FALSE;
1702    if (ctxvis->stereoMode && !bufvis->stereoMode)
1703       return GL_FALSE;
1704    if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
1705       return GL_FALSE;
1706    if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
1707       return GL_FALSE;
1708    if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
1709       return GL_FALSE;
1710    if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
1711       return GL_FALSE;
1712    if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
1713       return GL_FALSE;
1714    if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
1715       return GL_FALSE;
1716    if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
1717       return GL_FALSE;
1718    if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
1719       return GL_FALSE;
1720
1721    return GL_TRUE;
1722 }
1723
1724
1725 /**
1726  * Bind the given context to the given draw-buffer and read-buffer and
1727  * make it the current context for this thread.
1728  *
1729  * \param newCtx new GL context. If NULL then there will be no current GL
1730  * context.
1731  * \param drawBuffer draw framebuffer.
1732  * \param readBuffer read framebuffer.
1733  *
1734  * Check that the context's and framebuffer's visuals are compatible, returning
1735  * immediately otherwise. Sets the glapi current context via
1736  * _glapi_set_context(). If \p newCtx is not NULL, associates \p drawBuffer and
1737  * \p readBuffer with it and calls dd_function_table::ResizeBuffers if the buffers size has changed.
1738  * Calls dd_function_table::MakeCurrent callback if defined.
1739  *
1740  * When a context is bound by the first time and the \c MESA_INFO environment
1741  * variable is set it calls print_info() as an aid for remote user
1742  * troubleshooting.
1743  */
1744 void
1745 _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
1746                     GLframebuffer *readBuffer )
1747 {
1748    if (MESA_VERBOSE)
1749       _mesa_debug(newCtx, "_mesa_make_current()\n");
1750
1751    /* Check that the context's and framebuffer's visuals are compatible.
1752     */
1753    if (newCtx && drawBuffer && newCtx->DrawBuffer != drawBuffer) {
1754       if (!check_compatible(newCtx, drawBuffer))
1755          return;
1756    }
1757    if (newCtx && readBuffer && newCtx->ReadBuffer != readBuffer) {
1758       if (!check_compatible(newCtx, readBuffer))
1759          return;
1760    }
1761
1762    /* We call this function periodically (just here for now) in
1763     * order to detect when multithreading has begun.
1764     */
1765    _glapi_check_multithread();
1766
1767    _glapi_set_context((void *) newCtx);
1768    ASSERT(_mesa_get_current_context() == newCtx);
1769
1770    if (!newCtx) {
1771       _glapi_set_dispatch(NULL);  /* none current */
1772    }
1773    else {
1774       _glapi_set_dispatch(newCtx->CurrentDispatch);
1775
1776       if (drawBuffer && readBuffer) {
1777          /* TODO: check if newCtx and buffer's visual match??? */
1778
1779 #if NEW_RENDERBUFFER
1780          ASSERT(drawBuffer->Name == 0);
1781          ASSERT(readBuffer->Name == 0);
1782          newCtx->WinSysDrawBuffer = drawBuffer;
1783          newCtx->WinSysReadBuffer = readBuffer;
1784          /* don't replace user-buffer bindings with window system buffer */
1785          if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
1786             newCtx->DrawBuffer = drawBuffer;
1787             newCtx->ReadBuffer = readBuffer;
1788          }
1789 #else
1790          newCtx->DrawBuffer = drawBuffer;
1791          newCtx->ReadBuffer = readBuffer;
1792 #endif
1793          newCtx->NewState |= _NEW_BUFFERS;
1794
1795 #if _HAVE_FULL_GL
1796          if (!drawBuffer->Initialized) {
1797             /* get initial window size */
1798             GLuint bufWidth, bufHeight;
1799             /* ask device driver for size of the buffer */
1800             (*newCtx->Driver.GetBufferSize)(drawBuffer, &bufWidth, &bufHeight);
1801             /* set initial buffer size */
1802             if (newCtx->Driver.ResizeBuffers)
1803                newCtx->Driver.ResizeBuffers(newCtx, drawBuffer,
1804                                             bufWidth, bufHeight);
1805             drawBuffer->Initialized = GL_TRUE;
1806          }
1807
1808          if (readBuffer != drawBuffer && !readBuffer->Initialized) {
1809             /* get initial window size */
1810             GLuint bufWidth, bufHeight;
1811             /* ask device driver for size of the buffer */
1812             (*newCtx->Driver.GetBufferSize)(readBuffer, &bufWidth, &bufHeight);
1813             /* set initial buffer size */
1814             if (newCtx->Driver.ResizeBuffers)
1815                newCtx->Driver.ResizeBuffers(newCtx, readBuffer,
1816                                             bufWidth, bufHeight);
1817             readBuffer->Initialized = GL_TRUE;
1818          }
1819 #endif
1820          if (newCtx->FirstTimeCurrent) {
1821             /* set initial viewport and scissor size now */
1822             _mesa_set_viewport(newCtx, 0, 0, drawBuffer->Width, drawBuffer->Height);
1823             newCtx->Scissor.Width = drawBuffer->Width;
1824             newCtx->Scissor.Height = drawBuffer->Height;
1825          }
1826       }
1827
1828       /* Alert the driver - usually passed on to the sw t&l module,
1829        * but also used to detect threaded cases in the radeon codegen
1830        * hw t&l module.
1831        */
1832       if (newCtx->Driver.MakeCurrent)
1833          newCtx->Driver.MakeCurrent( newCtx, drawBuffer, readBuffer );
1834
1835       /* We can use this to help debug user's problems.  Tell them to set
1836        * the MESA_INFO env variable before running their app.  Then the
1837        * first time each context is made current we'll print some useful
1838        * information.
1839        */
1840       if (newCtx->FirstTimeCurrent) {
1841          if (_mesa_getenv("MESA_INFO")) {
1842             _mesa_print_info();
1843          }
1844          newCtx->FirstTimeCurrent = GL_FALSE;
1845       }
1846    }
1847 }
1848
1849
1850 /**
1851  * Make context 'ctx' share the display lists, textures and programs
1852  * that are associated with 'ctxToShare'.
1853  * Any display lists, textures or programs associated with 'ctx' will
1854  * be deleted if nobody else is sharing them.
1855  */
1856 GLboolean
1857 _mesa_share_state(GLcontext *ctx, GLcontext *ctxToShare)
1858 {
1859    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1860       ctx->Shared->RefCount--;
1861       if (ctx->Shared->RefCount == 0) {
1862          free_shared_state(ctx, ctx->Shared);
1863       }
1864       ctx->Shared = ctxToShare->Shared;
1865       ctx->Shared->RefCount++;
1866       return GL_TRUE;
1867    }
1868    else {
1869       return GL_FALSE;
1870    }
1871 }
1872
1873
1874
1875 /**
1876  * Get current context for the calling thread.
1877  *
1878  * \return pointer to the current GL context.
1879  *
1880  * Calls _glapi_get_context(). This isn't the fastest way to get the current
1881  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in context.h.
1882  */
1883 GLcontext *
1884 _mesa_get_current_context( void )
1885 {
1886    return (GLcontext *) _glapi_get_context();
1887 }
1888
1889 /**
1890  * Get context's current API dispatch table.
1891  *
1892  * It'll either be the immediate-mode execute dispatcher or the display list
1893  * compile dispatcher.
1894  *
1895  * \param ctx GL context.
1896  *
1897  * \return pointer to dispatch_table.
1898  *
1899  * Simply returns __GLcontextRec::CurrentDispatch.
1900  */
1901 struct _glapi_table *
1902 _mesa_get_dispatch(GLcontext *ctx)
1903 {
1904    return ctx->CurrentDispatch;
1905 }
1906
1907 /*@}*/
1908
1909
1910 /**********************************************************************/
1911 /** \name Miscellaneous functions                                     */
1912 /**********************************************************************/
1913 /*@{*/
1914
1915 /**
1916  * Record an error.
1917  *
1918  * \param ctx GL context.
1919  * \param error error code.
1920  *
1921  * Records the given error code and call the driver's dd_function_table::Error
1922  * function if defined.
1923  *
1924  * \sa
1925  * This is called via _mesa_error().
1926  */
1927 void
1928 _mesa_record_error( GLcontext *ctx, GLenum error )
1929 {
1930    if (!ctx)
1931       return;
1932
1933    if (ctx->ErrorValue == GL_NO_ERROR) {
1934       ctx->ErrorValue = error;
1935    }
1936
1937    /* Call device driver's error handler, if any.  This is used on the Mac. */
1938    if (ctx->Driver.Error) {
1939       (*ctx->Driver.Error)( ctx );
1940    }
1941 }
1942
1943 /**
1944  * Execute glFinish().
1945  *
1946  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1947  * dd_function_table::Finish driver callback, if not NULL.
1948  */
1949 void GLAPIENTRY
1950 _mesa_Finish( void )
1951 {
1952    GET_CURRENT_CONTEXT(ctx);
1953    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1954    if (ctx->Driver.Finish) {
1955       (*ctx->Driver.Finish)( ctx );
1956    }
1957 }
1958
1959 /**
1960  * Execute glFlush().
1961  *
1962  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1963  * dd_function_table::Flush driver callback, if not NULL.
1964  */
1965 void GLAPIENTRY
1966 _mesa_Flush( void )
1967 {
1968    GET_CURRENT_CONTEXT(ctx);
1969    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1970    if (ctx->Driver.Flush) {
1971       (*ctx->Driver.Flush)( ctx );
1972    }
1973 }
1974
1975
1976 /*@}*/