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