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