src/mesa/main/context.c

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