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 #if FEATURE_EXT_framebuffer_object
 568    ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
 569    ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
 570 #endif
 571
 572 #if FEATURE_ARB_vertex_shader
 573    ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
 574    ctx->Const.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
 575    ctx->Const.MaxVarying = MAX_VARYING;
 576 #endif
 577
 578    /* GL_ARB_framebuffer_object */
 579    ctx->Const.MaxSamples = 0;
 580
 581    /* GL_ARB_sync */
 582    ctx->Const.MaxServerWaitTimeout = (GLuint64) ~0;
 583
 584    /* GL_ATI_envmap_bumpmap */
 585    ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS;
 586
 587    /* GL_EXT_provoking_vertex */
 588    ctx->Const.QuadsFollowProvokingVertexConvention = GL_TRUE;
 589
 590    /* sanity checks */
 591    ASSERT(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,
 592                                              ctx->Const.MaxTextureCoordUnits));
 593    ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
 594    ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
 595
 596    ASSERT(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
 597    ASSERT(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
 598    ASSERT(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);
 599    ASSERT(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);
 600
 601    /* check that we don't exceed the size of various bitfields */
 602    ASSERT(VERT_RESULT_MAX <=
 603           (8 * sizeof(ctx->VertexProgram._Current->Base.OutputsWritten)));
 604    ASSERT(FRAG_ATTRIB_MAX <=
 605           (8 * sizeof(ctx->FragmentProgram._Current->Base.InputsRead)));
 606 }
 607
 608
 609 /**
 610  * Do some sanity checks on the limits/constants for the given context.
 611  * Only called the first time a context is bound.
 612  */
 613 static void
 614 check_context_limits(GLcontext *ctx)
 615 {
 616    /* Many context limits/constants are limited by the size of
 617     * internal arrays.
 618     */
 619    assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
 620    assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
 621    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
 622    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
 623
 624    /* number of coord units cannot be greater than number of image units */
 625    assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits);
 626
 627    assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
 628    assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
 629    assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
 630    assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
 631
 632    /* make sure largest texture image is <= MAX_WIDTH in size */
 633    assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= MAX_WIDTH);
 634    assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= MAX_WIDTH);
 635    assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= MAX_WIDTH);
 636
 637    assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);
 638    assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);
 639
 640    assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
 641
 642    /* XXX probably add more tests */
 643 }
 644
 645
 646 /**
 647  * Initialize the attribute groups in a GL context.
 648  *
 649  * \param ctx GL context.
 650  *
 651  * Initializes all the attributes, calling the respective <tt>init*</tt>
 652  * functions for the more complex data structures.
 653  */
 654 static GLboolean
 655 init_attrib_groups(GLcontext *ctx)
 656 {
 657    assert(ctx);
 658
 659    /* Constants */
 660    _mesa_init_constants( ctx );
 661
 662    /* Extensions */
 663    _mesa_init_extensions( ctx );
 664
 665    /* Attribute Groups */
 666    _mesa_init_accum( ctx );
 667    _mesa_init_attrib( ctx );
 668    _mesa_init_buffer_objects( ctx );
 669    _mesa_init_color( ctx );
 670    _mesa_init_colortables( ctx );
 671    _mesa_init_current( ctx );
 672    _mesa_init_depth( ctx );
 673    _mesa_init_debug( ctx );
 674    _mesa_init_display_list( ctx );
 675    _mesa_init_eval( ctx );
 676    _mesa_init_fbobjects( ctx );
 677    _mesa_init_feedback( ctx );
 678    _mesa_init_fog( ctx );
 679    _mesa_init_histogram( ctx );
 680    _mesa_init_hint( ctx );
 681    _mesa_init_line( ctx );
 682    _mesa_init_lighting( ctx );
 683    _mesa_init_matrix( ctx );
 684    _mesa_init_multisample( ctx );
 685    _mesa_init_pixel( ctx );
 686    _mesa_init_pixelstore( ctx );
 687    _mesa_init_point( ctx );
 688    _mesa_init_polygon( ctx );
 689    _mesa_init_program( ctx );
 690    _mesa_init_queryobj( ctx );
 691 #if FEATURE_ARB_sync
 692    _mesa_init_sync( ctx );
 693 #endif
 694    _mesa_init_rastpos( ctx );
 695    _mesa_init_scissor( ctx );
 696    _mesa_init_shader_state( ctx );
 697    _mesa_init_stencil( ctx );
 698    _mesa_init_transform( ctx );
 699    _mesa_init_varray( ctx );
 700    _mesa_init_viewport( ctx );
 701
 702    if (!_mesa_init_texture( ctx ))
 703       return GL_FALSE;
 704
 705    _mesa_init_texture_s3tc( ctx );
 706
 707    /* Miscellaneous */
 708    ctx->NewState = _NEW_ALL;
 709    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
 710    ctx->varying_vp_inputs = ~0;
 711
 712    return GL_TRUE;
 713 }
 714
 715
 716 /**
 717  * Update default objects in a GL context with respect to shared state.
 718  *
 719  * \param ctx GL context.
 720  *
 721  * Removes references to old default objects, (texture objects, program
 722  * objects, etc.) and changes to reference those from the current shared
 723  * state.
 724  */
 725 static GLboolean
 726 update_default_objects(GLcontext *ctx)
 727 {
 728    assert(ctx);
 729
 730    _mesa_update_default_objects_program(ctx);
 731    _mesa_update_default_objects_texture(ctx);
 732    _mesa_update_default_objects_buffer_objects(ctx);
 733
 734    return GL_TRUE;
 735 }
 736
 737
 738 /**
 739  * This is the default function we plug into all dispatch table slots
 740  * This helps prevents a segfault when someone calls a GL function without
 741  * first checking if the extension's supported.
 742  */
 743 static int
 744 generic_nop(void)
 745 {
 746    _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)");
 747    return 0;
 748 }
 749
 750
 751 /**
 752  * Allocate and initialize a new dispatch table.
 753  */
 754 static struct _glapi_table *
 755 alloc_dispatch_table(void)
 756 {
 757    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
 758     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
 759     * Mesa we do this to accomodate different versions of libGL and various
 760     * DRI drivers.
 761     */
 762    GLint numEntries = MAX2(_glapi_get_dispatch_table_size(),
 763                            sizeof(struct _glapi_table) / sizeof(_glapi_proc));
 764    struct _glapi_table *table =
 765       (struct _glapi_table *) _mesa_malloc(numEntries * sizeof(_glapi_proc));
 766    if (table) {
 767       _glapi_proc *entry = (_glapi_proc *) table;
 768       GLint i;
 769       for (i = 0; i < numEntries; i++) {
 770          entry[i] = (_glapi_proc) generic_nop;
 771       }
 772    }
 773    return table;
 774 }
 775
 776
 777 /**
 778  * Initialize a GLcontext struct (rendering context).
 779  *
 780  * This includes allocating all the other structs and arrays which hang off of
 781  * the context by pointers.
 782  * Note that the driver needs to pass in its dd_function_table here since
 783  * we need to at least call driverFunctions->NewTextureObject to create the
 784  * default texture objects.
 785  *
 786  * Called by _mesa_create_context().
 787  *
 788  * Performs the imports and exports callback tables initialization, and
 789  * miscellaneous one-time initializations. If no shared context is supplied one
 790  * is allocated, and increase its reference count.  Setups the GL API dispatch
 791  * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
 792  * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
 793  * for debug flags.
 794  *
 795  * \param ctx the context to initialize
 796  * \param visual describes the visual attributes for this context
 797  * \param share_list points to context to share textures, display lists,
 798  *        etc with, or NULL
 799  * \param driverFunctions table of device driver functions for this context
 800  *        to use
 801  * \param driverContext pointer to driver-specific context data
 802  */
 803 GLboolean
 804 _mesa_initialize_context(GLcontext *ctx,
 805                          const GLvisual *visual,
 806                          GLcontext *share_list,
 807                          const struct dd_function_table *driverFunctions,
 808                          void *driverContext)
 809 {
 810    struct gl_shared_state *shared;
 811
 812    /*ASSERT(driverContext);*/
 813    assert(driverFunctions->NewTextureObject);
 814    assert(driverFunctions->FreeTexImageData);
 815
 816    /* misc one-time initializations */
 817    one_time_init(ctx);
 818
 819    ctx->Visual = *visual;
 820    ctx->DrawBuffer = NULL;
 821    ctx->ReadBuffer = NULL;
 822    ctx->WinSysDrawBuffer = NULL;
 823    ctx->WinSysReadBuffer = NULL;
 824
 825    /* Plug in driver functions and context pointer here.
 826     * This is important because when we call alloc_shared_state() below
 827     * we'll call ctx->Driver.NewTextureObject() to create the default
 828     * textures.
 829     */
 830    ctx->Driver = *driverFunctions;
 831    ctx->DriverCtx = driverContext;
 832
 833    if (share_list) {
 834       /* share state with another context */
 835       shared = share_list->Shared;
 836    }
 837    else {
 838       /* allocate new, unshared state */
 839       shared = _mesa_alloc_shared_state(ctx);
 840       if (!shared)
 841          return GL_FALSE;
 842    }
 843
 844    _glthread_LOCK_MUTEX(shared->Mutex);
 845    ctx->Shared = shared;
 846    shared->RefCount++;
 847    _glthread_UNLOCK_MUTEX(shared->Mutex);
 848
 849    if (!init_attrib_groups( ctx )) {
 850       _mesa_free_shared_state(ctx, ctx->Shared);
 851       return GL_FALSE;
 852    }
 853
 854    /* setup the API dispatch tables */
 855    ctx->Exec = alloc_dispatch_table();
 856    ctx->Save = alloc_dispatch_table();
 857    if (!ctx->Exec || !ctx->Save) {
 858       _mesa_free_shared_state(ctx, ctx->Shared);
 859       if (ctx->Exec)
 860          _mesa_free(ctx->Exec);
 861       return GL_FALSE;
 862    }
 863 #if FEATURE_dispatch
 864    _mesa_init_exec_table(ctx->Exec);
 865 #endif
 866    ctx->CurrentDispatch = ctx->Exec;
 867
 868 #if FEATURE_dlist
 869    _mesa_init_save_table(ctx->Save);
 870    _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
 871 #endif
 872
 873    /* Neutral tnl module stuff */
 874    _mesa_init_exec_vtxfmt( ctx );
 875    ctx->TnlModule.Current = NULL;
 876    ctx->TnlModule.SwapCount = 0;
 877
 878    ctx->FragmentProgram._MaintainTexEnvProgram
 879       = (_mesa_getenv("MESA_TEX_PROG") != NULL);
 880
 881    ctx->VertexProgram._MaintainTnlProgram
 882       = (_mesa_getenv("MESA_TNL_PROG") != NULL);
 883    if (ctx->VertexProgram._MaintainTnlProgram) {
 884       /* this is required... */
 885       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
 886    }
 887
 888 #ifdef FEATURE_extra_context_init
 889    _mesa_initialize_context_extra(ctx);
 890 #endif
 891
 892    ctx->FirstTimeCurrent = GL_TRUE;
 893
 894    return GL_TRUE;
 895 }
 896
 897
 898 /**
 899  * Allocate and initialize a GLcontext structure.
 900  * Note that the driver needs to pass in its dd_function_table here since
 901  * we need to at least call driverFunctions->NewTextureObject to initialize
 902  * the rendering context.
 903  *
 904  * \param visual a GLvisual pointer (we copy the struct contents)
 905  * \param share_list another context to share display lists with or NULL
 906  * \param driverFunctions points to the dd_function_table into which the
 907  *        driver has plugged in all its special functions.
 908  * \param driverContext points to the device driver's private context state
 909  *
 910  * \return pointer to a new __GLcontextRec or NULL if error.
 911  */
 912 GLcontext *
 913 _mesa_create_context(const GLvisual *visual,
 914                      GLcontext *share_list,
 915                      const struct dd_function_table *driverFunctions,
 916                      void *driverContext)
 917 {
 918    GLcontext *ctx;
 919
 920    ASSERT(visual);
 921    /*ASSERT(driverContext);*/
 922
 923    ctx = (GLcontext *) _mesa_calloc(sizeof(GLcontext));
 924    if (!ctx)
 925       return NULL;
 926
 927    if (_mesa_initialize_context(ctx, visual, share_list,
 928                                 driverFunctions, driverContext)) {
 929       return ctx;
 930    }
 931    else {
 932       _mesa_free(ctx);
 933       return NULL;
 934    }
 935 }
 936
 937
 938 /**
 939  * Free the data associated with the given context.
 940  *
 941  * But doesn't free the GLcontext struct itself.
 942  *
 943  * \sa _mesa_initialize_context() and init_attrib_groups().
 944  */
 945 void
 946 _mesa_free_context_data( GLcontext *ctx )
 947 {
 948    GLint RefCount;
 949
 950    if (!_mesa_get_current_context()){
 951       /* No current context, but we may need one in order to delete
 952        * texture objs, etc.  So temporarily bind the context now.
 953        */
 954       _mesa_make_current(ctx, NULL, NULL);
 955    }
 956
 957    /* unreference WinSysDraw/Read buffers */
 958    _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
 959    _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
 960    _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
 961    _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
 962
 963    _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
 964    _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
 965    _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL);
 966
 967    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
 968    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
 969    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
 970
 971    _mesa_free_attrib_data(ctx);
 972    _mesa_free_lighting_data( ctx );
 973    _mesa_free_eval_data( ctx );
 974    _mesa_free_texture_data( ctx );
 975    _mesa_free_matrix_data( ctx );
 976    _mesa_free_viewport_data( ctx );
 977    _mesa_free_colortables_data( ctx );
 978    _mesa_free_program_data(ctx);
 979    _mesa_free_shader_state(ctx);
 980    _mesa_free_queryobj_data(ctx);
 981 #if FEATURE_ARB_sync
 982    _mesa_free_sync_data(ctx);
 983 #endif
 984    _mesa_free_varray_data(ctx);
 985
 986    _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);
 987
 988 #if FEATURE_ARB_pixel_buffer_object
 989    _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
 990    _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
 991 #endif
 992
 993 #if FEATURE_ARB_vertex_buffer_object
 994    _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
 995    _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);
 996 #endif
 997
 998    /* free dispatch tables */
 999    _mesa_free(ctx->Exec);
1000    _mesa_free(ctx->Save);
1001
1002    /* Shared context state (display lists, textures, etc) */
1003    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1004    RefCount = --ctx->Shared->RefCount;
1005    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1006    assert(RefCount >= 0);
1007    if (RefCount == 0) {
1008       /* free shared state */
1009       _mesa_free_shared_state( ctx, ctx->Shared );
1010    }
1011
1012    /* needs to be after freeing shared state */
1013    _mesa_free_display_list_data(ctx);
1014
1015    if (ctx->Extensions.String)
1016       _mesa_free((void *) ctx->Extensions.String);
1017
1018    if (ctx->VersionString)
1019       _mesa_free(ctx->VersionString);
1020
1021    /* unbind the context if it's currently bound */
1022    if (ctx == _mesa_get_current_context()) {
1023       _mesa_make_current(NULL, NULL, NULL);
1024    }
1025 }
1026
1027
1028 /**
1029  * Destroy a GLcontext structure.
1030  *
1031  * \param ctx GL context.
1032  *
1033  * Calls _mesa_free_context_data() and frees the GLcontext structure itself.
1034  */
1035 void
1036 _mesa_destroy_context( GLcontext *ctx )
1037 {
1038    if (ctx) {
1039       _mesa_free_context_data(ctx);
1040       _mesa_free( (void *) ctx );
1041    }
1042 }
1043
1044
1045 #if _HAVE_FULL_GL
1046 /**
1047  * Copy attribute groups from one context to another.
1048  *
1049  * \param src source context
1050  * \param dst destination context
1051  * \param mask bitwise OR of GL_*_BIT flags
1052  *
1053  * According to the bits specified in \p mask, copies the corresponding
1054  * attributes from \p src into \p dst.  For many of the attributes a simple \c
1055  * memcpy is not enough due to the existence of internal pointers in their data
1056  * structures.
1057  */
1058 void
1059 _mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1060 {
1061    if (mask & GL_ACCUM_BUFFER_BIT) {
1062       /* OK to memcpy */
1063       dst->Accum = src->Accum;
1064    }
1065    if (mask & GL_COLOR_BUFFER_BIT) {
1066       /* OK to memcpy */
1067       dst->Color = src->Color;
1068    }
1069    if (mask & GL_CURRENT_BIT) {
1070       /* OK to memcpy */
1071       dst->Current = src->Current;
1072    }
1073    if (mask & GL_DEPTH_BUFFER_BIT) {
1074       /* OK to memcpy */
1075       dst->Depth = src->Depth;
1076    }
1077    if (mask & GL_ENABLE_BIT) {
1078       /* no op */
1079    }
1080    if (mask & GL_EVAL_BIT) {
1081       /* OK to memcpy */
1082       dst->Eval = src->Eval;
1083    }
1084    if (mask & GL_FOG_BIT) {
1085       /* OK to memcpy */
1086       dst->Fog = src->Fog;
1087    }
1088    if (mask & GL_HINT_BIT) {
1089       /* OK to memcpy */
1090       dst->Hint = src->Hint;
1091    }
1092    if (mask & GL_LIGHTING_BIT) {
1093       GLuint i;
1094       /* begin with memcpy */
1095       dst->Light = src->Light;
1096       /* fixup linked lists to prevent pointer insanity */
1097       make_empty_list( &(dst->Light.EnabledList) );
1098       for (i = 0; i < MAX_LIGHTS; i++) {
1099          if (dst->Light.Light[i].Enabled) {
1100             insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
1101          }
1102       }
1103    }
1104    if (mask & GL_LINE_BIT) {
1105       /* OK to memcpy */
1106       dst->Line = src->Line;
1107    }
1108    if (mask & GL_LIST_BIT) {
1109       /* OK to memcpy */
1110       dst->List = src->List;
1111    }
1112    if (mask & GL_PIXEL_MODE_BIT) {
1113       /* OK to memcpy */
1114       dst->Pixel = src->Pixel;
1115    }
1116    if (mask & GL_POINT_BIT) {
1117       /* OK to memcpy */
1118       dst->Point = src->Point;
1119    }
1120    if (mask & GL_POLYGON_BIT) {
1121       /* OK to memcpy */
1122       dst->Polygon = src->Polygon;
1123    }
1124    if (mask & GL_POLYGON_STIPPLE_BIT) {
1125       /* Use loop instead of MEMCPY due to problem with Portland Group's
1126        * C compiler.  Reported by John Stone.
1127        */
1128       GLuint i;
1129       for (i = 0; i < 32; i++) {
1130          dst->PolygonStipple[i] = src->PolygonStipple[i];
1131       }
1132    }
1133    if (mask & GL_SCISSOR_BIT) {
1134       /* OK to memcpy */
1135       dst->Scissor = src->Scissor;
1136    }
1137    if (mask & GL_STENCIL_BUFFER_BIT) {
1138       /* OK to memcpy */
1139       dst->Stencil = src->Stencil;
1140    }
1141    if (mask & GL_TEXTURE_BIT) {
1142       /* Cannot memcpy because of pointers */
1143       _mesa_copy_texture_state(src, dst);
1144    }
1145    if (mask & GL_TRANSFORM_BIT) {
1146       /* OK to memcpy */
1147       dst->Transform = src->Transform;
1148    }
1149    if (mask & GL_VIEWPORT_BIT) {
1150       /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
1151       dst->Viewport.X = src->Viewport.X;
1152       dst->Viewport.Y = src->Viewport.Y;
1153       dst->Viewport.Width = src->Viewport.Width;
1154       dst->Viewport.Height = src->Viewport.Height;
1155       dst->Viewport.Near = src->Viewport.Near;
1156       dst->Viewport.Far = src->Viewport.Far;
1157       _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
1158    }
1159
1160    /* XXX FIXME:  Call callbacks?
1161     */
1162    dst->NewState = _NEW_ALL;
1163 }
1164 #endif
1165
1166
1167 /**
1168  * Check if the given context can render into the given framebuffer
1169  * by checking visual attributes.
1170  *
1171  * Most of these tests could go away because Mesa is now pretty flexible
1172  * in terms of mixing rendering contexts with framebuffers.  As long
1173  * as RGB vs. CI mode agree, we're probably good.
1174  *
1175  * \return GL_TRUE if compatible, GL_FALSE otherwise.
1176  */
1177 static GLboolean
1178 check_compatible(const GLcontext *ctx, const GLframebuffer *buffer)
1179 {
1180    const GLvisual *ctxvis = &ctx->Visual;
1181    const GLvisual *bufvis = &buffer->Visual;
1182
1183    if (ctxvis == bufvis)
1184       return GL_TRUE;
1185
1186    if (ctxvis->rgbMode != bufvis->rgbMode)
1187       return GL_FALSE;
1188 #if 0
1189    /* disabling this fixes the fgl_glxgears pbuffer demo */
1190    if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
1191       return GL_FALSE;
1192 #endif
1193    if (ctxvis->stereoMode && !bufvis->stereoMode)
1194       return GL_FALSE;
1195    if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
1196       return GL_FALSE;
1197    if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
1198       return GL_FALSE;
1199    if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
1200       return GL_FALSE;
1201    if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
1202       return GL_FALSE;
1203    if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
1204       return GL_FALSE;
1205    if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
1206       return GL_FALSE;
1207 #if 0
1208    /* disabled (see bug 11161) */
1209    if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
1210       return GL_FALSE;
1211 #endif
1212    if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
1213       return GL_FALSE;
1214
1215    return GL_TRUE;
1216 }
1217
1218
1219 /**
1220  * Do one-time initialization for the given framebuffer.  Specifically,
1221  * ask the driver for the window's current size and update the framebuffer
1222  * object to match.
1223  * Really, the device driver should totally take care of this.
1224  */
1225 static void
1226 initialize_framebuffer_size(GLcontext *ctx, GLframebuffer *fb)
1227 {
1228    GLuint width, height;
1229    if (ctx->Driver.GetBufferSize) {
1230       ctx->Driver.GetBufferSize(fb, &width, &height);
1231       if (ctx->Driver.ResizeBuffers)
1232          ctx->Driver.ResizeBuffers(ctx, fb, width, height);
1233       fb->Initialized = GL_TRUE;
1234    }
1235 }
1236
1237
1238 /**
1239  * Check if the viewport/scissor size has not yet been initialized.
1240  * Initialize the size if the given width and height are non-zero.
1241  */
1242 void
1243 _mesa_check_init_viewport(GLcontext *ctx, GLuint width, GLuint height)
1244 {
1245    if (!ctx->ViewportInitialized && width > 0 && height > 0) {
1246       /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
1247        * potential infinite recursion.
1248        */
1249       ctx->ViewportInitialized = GL_TRUE;
1250       _mesa_set_viewport(ctx, 0, 0, width, height);
1251       _mesa_set_scissor(ctx, 0, 0, width, height);
1252    }
1253 }
1254
1255
1256 /**
1257  * Bind the given context to the given drawBuffer and readBuffer and
1258  * make it the current context for the calling thread.
1259  * We'll render into the drawBuffer and read pixels from the
1260  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1261  *
1262  * We check that the context's and framebuffer's visuals are compatible
1263  * and return immediately if they're not.
1264  *
1265  * \param newCtx  the new GL context. If NULL then there will be no current GL
1266  *                context.
1267  * \param drawBuffer  the drawing framebuffer
1268  * \param readBuffer  the reading framebuffer
1269  */
1270 GLboolean
1271 _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
1272                     GLframebuffer *readBuffer )
1273 {
1274    if (MESA_VERBOSE & VERBOSE_API)
1275       _mesa_debug(newCtx, "_mesa_make_current()\n");
1276
1277    /* Check that the context's and framebuffer's visuals are compatible.
1278     */
1279    if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1280       if (!check_compatible(newCtx, drawBuffer)) {
1281          _mesa_warning(newCtx,
1282               "MakeCurrent: incompatible visuals for context and drawbuffer");
1283          return GL_FALSE;
1284       }
1285    }
1286    if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1287       if (!check_compatible(newCtx, readBuffer)) {
1288          _mesa_warning(newCtx,
1289               "MakeCurrent: incompatible visuals for context and readbuffer");
1290          return GL_FALSE;
1291       }
1292    }
1293
1294    /* We used to call _glapi_check_multithread() here.  Now do it in drivers */
1295    _glapi_set_context((void *) newCtx);
1296    ASSERT(_mesa_get_current_context() == newCtx);
1297
1298    if (!newCtx) {
1299       _glapi_set_dispatch(NULL);  /* none current */
1300    }
1301    else {
1302       _glapi_set_dispatch(newCtx->CurrentDispatch);
1303
1304       if (drawBuffer && readBuffer) {
1305          /* TODO: check if newCtx and buffer's visual match??? */
1306
1307          ASSERT(drawBuffer->Name == 0);
1308          ASSERT(readBuffer->Name == 0);
1309          _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1310          _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1311
1312          /*
1313           * Only set the context's Draw/ReadBuffer fields if they're NULL
1314           * or not bound to a user-created FBO.
1315           */
1316          if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
1317             /* KW: merge conflict here, revisit.
1318              */
1319             /* fix up the fb fields - these will end up wrong otherwise
1320              * if the DRIdrawable changes, and everything relies on them.
1321              * This is a bit messy (same as needed in _mesa_BindFramebufferEXT)
1322              */
1323             unsigned int i;
1324             GLenum buffers[MAX_DRAW_BUFFERS];
1325
1326             _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1327
1328             for(i = 0; i < newCtx->Const.MaxDrawBuffers; i++) {
1329                buffers[i] = newCtx->Color.DrawBuffer[i];
1330             }
1331
1332             _mesa_drawbuffers(newCtx, newCtx->Const.MaxDrawBuffers, buffers, NULL);
1333          }
1334          if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {
1335             _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1336          }
1337
1338          /* XXX only set this flag if we're really changing the draw/read
1339           * framebuffer bindings.
1340           */
1341          newCtx->NewState |= _NEW_BUFFERS;
1342
1343 #if 1
1344          /* We want to get rid of these lines: */
1345
1346 #if _HAVE_FULL_GL
1347          if (!drawBuffer->Initialized) {
1348             initialize_framebuffer_size(newCtx, drawBuffer);
1349          }
1350          if (readBuffer != drawBuffer && !readBuffer->Initialized) {
1351             initialize_framebuffer_size(newCtx, readBuffer);
1352          }
1353
1354          _mesa_resizebuffers(newCtx);
1355 #endif
1356
1357 #else
1358          /* We want the drawBuffer and readBuffer to be initialized by
1359           * the driver.
1360           * This generally means the Width and Height match the actual
1361           * window size and the renderbuffers (both hardware and software
1362           * based) are allocated to match.  The later can generally be
1363           * done with a call to _mesa_resize_framebuffer().
1364           *
1365           * It's theoretically possible for a buffer to have zero width
1366           * or height, but for now, assert check that the driver did what's
1367           * expected of it.
1368           */
1369          ASSERT(drawBuffer->Width > 0);
1370          ASSERT(drawBuffer->Height > 0);
1371 #endif
1372
1373          if (drawBuffer) {
1374             _mesa_check_init_viewport(newCtx,
1375                                       drawBuffer->Width, drawBuffer->Height);
1376          }
1377       }
1378
1379       if (newCtx->FirstTimeCurrent) {
1380          _mesa_compute_version(newCtx);
1381
1382          check_context_limits(newCtx);
1383
1384          /* We can use this to help debug user's problems.  Tell them to set
1385           * the MESA_INFO env variable before running their app.  Then the
1386           * first time each context is made current we'll print some useful
1387           * information.
1388           */
1389          if (_mesa_getenv("MESA_INFO")) {
1390             _mesa_print_info();
1391          }
1392
1393          newCtx->FirstTimeCurrent = GL_FALSE;
1394       }
1395    }
1396
1397    return GL_TRUE;
1398 }
1399
1400
1401 /**
1402  * Make context 'ctx' share the display lists, textures and programs
1403  * that are associated with 'ctxToShare'.
1404  * Any display lists, textures or programs associated with 'ctx' will
1405  * be deleted if nobody else is sharing them.
1406  */
1407 GLboolean
1408 _mesa_share_state(GLcontext *ctx, GLcontext *ctxToShare)
1409 {
1410    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1411       struct gl_shared_state *oldSharedState = ctx->Shared;
1412       GLint RefCount;
1413
1414       ctx->Shared = ctxToShare->Shared;
1415
1416       _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1417       ctx->Shared->RefCount++;
1418       _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1419
1420       update_default_objects(ctx);
1421
1422       _glthread_LOCK_MUTEX(oldSharedState->Mutex);
1423       RefCount = --oldSharedState->RefCount;
1424       _glthread_UNLOCK_MUTEX(oldSharedState->Mutex);
1425
1426       if (RefCount == 0) {
1427          _mesa_free_shared_state(ctx, oldSharedState);
1428       }
1429
1430       return GL_TRUE;
1431    }
1432    else {
1433       return GL_FALSE;
1434    }
1435 }
1436
1437
1438
1439 /**
1440  * \return pointer to the current GL context for this thread.
1441  *
1442  * Calls _glapi_get_context(). This isn't the fastest way to get the current
1443  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
1444  * context.h.
1445  */
1446 GLcontext *
1447 _mesa_get_current_context( void )
1448 {
1449    return (GLcontext *) _glapi_get_context();
1450 }
1451
1452
1453 /**
1454  * Get context's current API dispatch table.
1455  *
1456  * It'll either be the immediate-mode execute dispatcher or the display list
1457  * compile dispatcher.
1458  *
1459  * \param ctx GL context.
1460  *
1461  * \return pointer to dispatch_table.
1462  *
1463  * Simply returns __GLcontextRec::CurrentDispatch.
1464  */
1465 struct _glapi_table *
1466 _mesa_get_dispatch(GLcontext *ctx)
1467 {
1468    return ctx->CurrentDispatch;
1469 }
1470
1471 /*@}*/
1472
1473
1474 /**********************************************************************/
1475 /** \name Miscellaneous functions                                     */
1476 /**********************************************************************/
1477 /*@{*/
1478
1479 /**
1480  * Record an error.
1481  *
1482  * \param ctx GL context.
1483  * \param error error code.
1484  *
1485  * Records the given error code and call the driver's dd_function_table::Error
1486  * function if defined.
1487  *
1488  * \sa
1489  * This is called via _mesa_error().
1490  */
1491 void
1492 _mesa_record_error(GLcontext *ctx, GLenum error)
1493 {
1494    if (!ctx)
1495       return;
1496
1497    if (ctx->ErrorValue == GL_NO_ERROR) {
1498       ctx->ErrorValue = error;
1499    }
1500
1501    /* Call device driver's error handler, if any.  This is used on the Mac. */
1502    if (ctx->Driver.Error) {
1503       ctx->Driver.Error(ctx);
1504    }
1505 }
1506
1507
1508 /**
1509  * Flush commands and wait for completion.
1510  */
1511 void
1512 _mesa_finish(GLcontext *ctx)
1513 {
1514    FLUSH_CURRENT( ctx, 0 );
1515    if (ctx->Driver.Finish) {
1516       ctx->Driver.Finish(ctx);
1517    }
1518 }
1519
1520
1521 /**
1522  * Flush commands.
1523  */
1524 void
1525 _mesa_flush(GLcontext *ctx)
1526 {
1527    FLUSH_CURRENT( ctx, 0 );
1528    if (ctx->Driver.Flush) {
1529       ctx->Driver.Flush(ctx);
1530    }
1531 }
1532
1533
1534
1535 /**
1536  * Execute glFinish().
1537  *
1538  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1539  * dd_function_table::Finish driver callback, if not NULL.
1540  */
1541 void GLAPIENTRY
1542 _mesa_Finish(void)
1543 {
1544    GET_CURRENT_CONTEXT(ctx);
1545    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1546    _mesa_finish(ctx);
1547 }
1548
1549
1550 /**
1551  * Execute glFlush().
1552  *
1553  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1554  * dd_function_table::Flush driver callback, if not NULL.
1555  */
1556 void GLAPIENTRY
1557 _mesa_Flush(void)
1558 {
1559    GET_CURRENT_CONTEXT(ctx);
1560    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1561    _mesa_flush(ctx);
1562 }
1563
1564
1565 /**
1566  * Set mvp_with_dp4 flag.  If a driver has a preference for DP4 over
1567  * MUL/MAD, or vice versa, call this function to register that.
1568  * Otherwise we default to MUL/MAD.
1569  */
1570 void
1571 _mesa_set_mvp_with_dp4( GLcontext *ctx,
1572                         GLboolean flag )
1573 {
1574    ctx->mvp_with_dp4 = flag;
1575 }
1576
1577
1578
1579 /**
1580  * Prior to drawing anything with glBegin, glDrawArrays, etc. this function
1581  * is called to see if it's valid to render.  This involves checking that
1582  * the current shader is valid and the framebuffer is complete.
1583  * If an error is detected it'll be recorded here.
1584  * \return GL_TRUE if OK to render, GL_FALSE if not
1585  */
1586 GLboolean
1587 _mesa_valid_to_render(GLcontext *ctx, const char *where)
1588 {
1589    if (ctx->Shader.CurrentProgram) {
1590       /* using shaders */
1591       if (!ctx->Shader.CurrentProgram->LinkStatus) {
1592          _mesa_error(ctx, GL_INVALID_OPERATION,
1593                      "%s(shader not linked), where");
1594          return GL_FALSE;
1595       }
1596 #if 0 /* not normally enabled */
1597       {
1598          char errMsg[100];
1599          if (!_mesa_validate_shader_program(ctx, ctx->Shader.CurrentProgram,
1600                                             errMsg)) {
1601             _mesa_warning(ctx, "Shader program %u is invalid: %s",
1602                           ctx->Shader.CurrentProgram->Name, errMsg);
1603          }
1604       }
1605 #endif
1606    }
1607    else {
1608       if (ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) {
1609          _mesa_error(ctx, GL_INVALID_OPERATION,
1610                      "%s(vertex program not valid)", where);
1611          return GL_FALSE;
1612       }
1613       if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
1614          _mesa_error(ctx, GL_INVALID_OPERATION,
1615                      "%s(fragment program not valid)", where);
1616          return GL_FALSE;
1617       }
1618    }
1619
1620    if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
1621       _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
1622                   "%s(incomplete framebuffer)", where);
1623       return GL_FALSE;
1624    }
1625
1626 #ifdef DEBUG
1627    if (ctx->Shader.Flags & GLSL_LOG) {
1628       struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
1629       if (shProg) {
1630          if (!shProg->_Used) {
1631             /* This is the first time this shader is being used.
1632              * Append shader's constants/uniforms to log file.
1633              */
1634             GLuint i;
1635             for (i = 0; i < shProg->NumShaders; i++) {
1636                struct gl_shader *sh = shProg->Shaders[i];
1637                if (sh->Type == GL_VERTEX_SHADER) {
1638                   _mesa_append_uniforms_to_file(sh,
1639                                                 &shProg->VertexProgram->Base);
1640                }
1641                else if (sh->Type == GL_FRAGMENT_SHADER) {
1642                   _mesa_append_uniforms_to_file(sh,
1643                                                 &shProg->FragmentProgram->Base);
1644                }
1645             }
1646             shProg->_Used = GL_TRUE;
1647          }
1648       }
1649    }
1650 #endif
1651
1652    return GL_TRUE;
1653 }
1654
1655
1656 /*@}*/