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