src/mesa/main/context.c

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