src/mesa/main/context.c

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