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