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