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