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