src/mesa/main/context.c

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