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