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