src/mesa/main/context.c

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