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