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