src/mesa/main/context.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   5  * Copyright (C) 2008  VMware, Inc.  All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * 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 "imports.h"
  81 #include "accum.h"
  82 #include "api_exec.h"
  83 #include "api_loopback.h"
  84 #include "arrayobj.h"
  85 #include "attrib.h"
  86 #include "bbox.h"
  87 #include "blend.h"
  88 #include "buffers.h"
  89 #include "bufferobj.h"
  90 #include "context.h"
  91 #include "cpuinfo.h"
  92 #include "debug.h"
  93 #include "debug_output.h"
  94 #include "depth.h"
  95 #include "dlist.h"
  96 #include "eval.h"
  97 #include "extensions.h"
  98 #include "fbobject.h"
  99 #include "feedback.h"
 100 #include "fog.h"
 101 #include "formats.h"
 102 #include "framebuffer.h"
 103 #include "hint.h"
 104 #include "hash.h"
 105 #include "light.h"
 106 #include "lines.h"
 107 #include "macros.h"
 108 #include "matrix.h"
 109 #include "multisample.h"
 110 #include "performance_monitor.h"
 111 #include "pipelineobj.h"
 112 #include "pixel.h"
 113 #include "pixelstore.h"
 114 #include "points.h"
 115 #include "polygon.h"
 116 #include "queryobj.h"
 117 #include "syncobj.h"
 118 #include "rastpos.h"
 119 #include "remap.h"
 120 #include "scissor.h"
 121 #include "shared.h"
 122 #include "shaderobj.h"
 123 #include "shaderimage.h"
 124 #include "util/disk_cache.h"
 125 #include "util/strtod.h"
 126 #include "stencil.h"
 127 #include "texcompress_s3tc.h"
 128 #include "texstate.h"
 129 #include "transformfeedback.h"
 130 #include "mtypes.h"
 131 #include "varray.h"
 132 #include "version.h"
 133 #include "viewport.h"
 134 #include "program/program.h"
 135 #include "math/m_matrix.h"
 136 #include "main/dispatch.h" /* for _gloffset_COUNT */
 137 #include "macros.h"
 138
 139 #ifdef USE_SPARC_ASM
 140 #include "sparc/sparc.h"
 141 #endif
 142
 143 #include "compiler/glsl_types.h"
 144 #include "compiler/glsl/glsl_parser_extras.h"
 145 #include <stdbool.h>
 146
 147
 148 #ifndef MESA_VERBOSE
 149 int MESA_VERBOSE = 0;
 150 #endif
 151
 152 #ifndef MESA_DEBUG_FLAGS
 153 int MESA_DEBUG_FLAGS = 0;
 154 #endif
 155
 156
 157 /* ubyte -> float conversion */
 158 GLfloat _mesa_ubyte_to_float_color_tab[256];
 159
 160
 161
 162 /**
 163  * Swap buffers notification callback.
 164  *
 165  * \param ctx GL context.
 166  *
 167  * Called by window system just before swapping buffers.
 168  * We have to finish any pending rendering.
 169  */
 170 void
 171 _mesa_notifySwapBuffers(struct gl_context *ctx)
 172 {
 173    if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)
 174       _mesa_debug(ctx, "SwapBuffers\n");
 175    FLUSH_CURRENT( ctx, 0 );
 176    if (ctx->Driver.Flush) {
 177       ctx->Driver.Flush(ctx);
 178    }
 179 }
 180
 181
 182 /**********************************************************************/
 183 /** \name GL Visual allocation/destruction                            */
 184 /**********************************************************************/
 185 /*@{*/
 186
 187 /**
 188  * Allocates a struct gl_config structure and initializes it via
 189  * _mesa_initialize_visual().
 190  *
 191  * \param dbFlag double buffering
 192  * \param stereoFlag stereo buffer
 193  * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
 194  * is acceptable but the actual depth type will be GLushort or GLuint as
 195  * needed.
 196  * \param stencilBits requested minimum bits per stencil buffer value
 197  * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number
 198  * of bits per color component in accum buffer.
 199  * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
 200  * \param redBits number of bits per color component in frame buffer for RGB(A)
 201  * mode.  We always use 8 in core Mesa though.
 202  * \param greenBits same as above.
 203  * \param blueBits same as above.
 204  * \param alphaBits same as above.
 205  * \param numSamples not really used.
 206  *
 207  * \return pointer to new struct gl_config or NULL if requested parameters
 208  * can't be met.
 209  *
 210  * \note Need to add params for level and numAuxBuffers (at least)
 211  */
 212 struct gl_config *
 213 _mesa_create_visual( GLboolean dbFlag,
 214                      GLboolean stereoFlag,
 215                      GLint redBits,
 216                      GLint greenBits,
 217                      GLint blueBits,
 218                      GLint alphaBits,
 219                      GLint depthBits,
 220                      GLint stencilBits,
 221                      GLint accumRedBits,
 222                      GLint accumGreenBits,
 223                      GLint accumBlueBits,
 224                      GLint accumAlphaBits,
 225                      GLint numSamples )
 226 {
 227    struct gl_config *vis = CALLOC_STRUCT(gl_config);
 228    if (vis) {
 229       if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,
 230                                    redBits, greenBits, blueBits, alphaBits,
 231                                    depthBits, stencilBits,
 232                                    accumRedBits, accumGreenBits,
 233                                    accumBlueBits, accumAlphaBits,
 234                                    numSamples)) {
 235          free(vis);
 236          return NULL;
 237       }
 238    }
 239    return vis;
 240 }
 241
 242
 243 /**
 244  * Makes some sanity checks and fills in the fields of the struct
 245  * gl_config object with the given parameters.  If the caller needs to
 246  * set additional fields, he should just probably init the whole
 247  * gl_config object himself.
 248  *
 249  * \return GL_TRUE on success, or GL_FALSE on failure.
 250  *
 251  * \sa _mesa_create_visual() above for the parameter description.
 252  */
 253 GLboolean
 254 _mesa_initialize_visual( struct gl_config *vis,
 255                          GLboolean dbFlag,
 256                          GLboolean stereoFlag,
 257                          GLint redBits,
 258                          GLint greenBits,
 259                          GLint blueBits,
 260                          GLint alphaBits,
 261                          GLint depthBits,
 262                          GLint stencilBits,
 263                          GLint accumRedBits,
 264                          GLint accumGreenBits,
 265                          GLint accumBlueBits,
 266                          GLint accumAlphaBits,
 267                          GLint numSamples )
 268 {
 269    assert(vis);
 270
 271    if (depthBits < 0 || depthBits > 32) {
 272       return GL_FALSE;
 273    }
 274    if (stencilBits < 0 || stencilBits > 8) {
 275       return GL_FALSE;
 276    }
 277    assert(accumRedBits >= 0);
 278    assert(accumGreenBits >= 0);
 279    assert(accumBlueBits >= 0);
 280    assert(accumAlphaBits >= 0);
 281
 282    vis->rgbMode          = GL_TRUE;
 283    vis->doubleBufferMode = dbFlag;
 284    vis->stereoMode       = stereoFlag;
 285
 286    vis->redBits          = redBits;
 287    vis->greenBits        = greenBits;
 288    vis->blueBits         = blueBits;
 289    vis->alphaBits        = alphaBits;
 290    vis->rgbBits          = redBits + greenBits + blueBits;
 291
 292    vis->indexBits      = 0;
 293    vis->depthBits      = depthBits;
 294    vis->stencilBits    = stencilBits;
 295
 296    vis->accumRedBits   = accumRedBits;
 297    vis->accumGreenBits = accumGreenBits;
 298    vis->accumBlueBits  = accumBlueBits;
 299    vis->accumAlphaBits = accumAlphaBits;
 300
 301    vis->haveAccumBuffer   = accumRedBits > 0;
 302    vis->haveDepthBuffer   = depthBits > 0;
 303    vis->haveStencilBuffer = stencilBits > 0;
 304
 305    vis->numAuxBuffers = 0;
 306    vis->level = 0;
 307    vis->sampleBuffers = numSamples > 0 ? 1 : 0;
 308    vis->samples = numSamples;
 309
 310    return GL_TRUE;
 311 }
 312
 313
 314 /**
 315  * Destroy a visual and free its memory.
 316  *
 317  * \param vis visual.
 318  *
 319  * Frees the visual structure.
 320  */
 321 void
 322 _mesa_destroy_visual( struct gl_config *vis )
 323 {
 324    free(vis);
 325 }
 326
 327 /*@}*/
 328
 329
 330 /**********************************************************************/
 331 /** \name Context allocation, initialization, destroying
 332  *
 333  * The purpose of the most initialization functions here is to provide the
 334  * default state values according to the OpenGL specification.
 335  */
 336 /**********************************************************************/
 337 /*@{*/
 338
 339
 340 /**
 341  * One-time initialization mutex lock.
 342  *
 343  * \sa Used by one_time_init().
 344  */
 345 mtx_t OneTimeLock = _MTX_INITIALIZER_NP;
 346
 347
 348 /**
 349  * Calls all the various one-time-fini functions in Mesa
 350  */
 351
 352 static void
 353 one_time_fini(void)
 354 {
 355    _mesa_destroy_shader_compiler();
 356    _mesa_locale_fini();
 357 }
 358
 359 /**
 360  * Calls all the various one-time-init functions in Mesa.
 361  *
 362  * While holding a global mutex lock, calls several initialization functions,
 363  * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
 364  * defined.
 365  *
 366  * \sa _math_init().
 367  */
 368 static void
 369 one_time_init( struct gl_context *ctx )
 370 {
 371    static GLbitfield api_init_mask = 0x0;
 372
 373    mtx_lock(&OneTimeLock);
 374
 375    /* truly one-time init */
 376    if (!api_init_mask) {
 377       GLuint i;
 378
 379       STATIC_ASSERT(sizeof(GLbyte) == 1);
 380       STATIC_ASSERT(sizeof(GLubyte) == 1);
 381       STATIC_ASSERT(sizeof(GLshort) == 2);
 382       STATIC_ASSERT(sizeof(GLushort) == 2);
 383       STATIC_ASSERT(sizeof(GLint) == 4);
 384       STATIC_ASSERT(sizeof(GLuint) == 4);
 385
 386       _mesa_locale_init();
 387
 388       _mesa_one_time_init_extension_overrides();
 389
 390       _mesa_get_cpu_features();
 391
 392       for (i = 0; i < 256; i++) {
 393          _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
 394       }
 395
 396       atexit(one_time_fini);
 397
 398 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
 399       if (MESA_VERBOSE != 0) {
 400          _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
 401                      PACKAGE_VERSION, __DATE__, __TIME__);
 402       }
 403 #endif
 404    }
 405
 406    /* per-API one-time init */
 407    if (!(api_init_mask & (1 << ctx->API))) {
 408       _mesa_init_remap_table();
 409    }
 410
 411    api_init_mask |= 1 << ctx->API;
 412
 413    mtx_unlock(&OneTimeLock);
 414 }
 415
 416
 417 /**
 418  * Initialize fields of gl_current_attrib (aka ctx->Current.*)
 419  */
 420 static void
 421 _mesa_init_current(struct gl_context *ctx)
 422 {
 423    GLuint i;
 424
 425    /* Init all to (0,0,0,1) */
 426    for (i = 0; i < ARRAY_SIZE(ctx->Current.Attrib); i++) {
 427       ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
 428    }
 429
 430    /* redo special cases: */
 431    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );
 432    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
 433    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
 434    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
 435    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
 436    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
 437 }
 438
 439
 440 /**
 441  * Init vertex/fragment/geometry program limits.
 442  * Important: drivers should override these with actual limits.
 443  */
 444 static void
 445 init_program_limits(struct gl_constants *consts, gl_shader_stage stage,
 446                     struct gl_program_constants *prog)
 447 {
 448    prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
 449    prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
 450    prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
 451    prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
 452    prog->MaxTemps = MAX_PROGRAM_TEMPS;
 453    prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
 454    prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
 455    prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS;
 456
 457    switch (stage) {
 458    case MESA_SHADER_VERTEX:
 459       prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
 460       prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;
 461       prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
 462       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 463       prog->MaxInputComponents = 0; /* value not used */
 464       prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */
 465       break;
 466    case MESA_SHADER_FRAGMENT:
 467       prog->MaxParameters = MAX_FRAGMENT_PROGRAM_PARAMS;
 468       prog->MaxAttribs = MAX_FRAGMENT_PROGRAM_INPUTS;
 469       prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
 470       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 471       prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */
 472       prog->MaxOutputComponents = 0; /* value not used */
 473       break;
 474    case MESA_SHADER_TESS_CTRL:
 475    case MESA_SHADER_TESS_EVAL:
 476    case MESA_SHADER_GEOMETRY:
 477       prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
 478       prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;
 479       prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
 480       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 481       prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */
 482       prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */
 483       break;
 484    case MESA_SHADER_COMPUTE:
 485       prog->MaxParameters = 0; /* not meaningful for compute shaders */
 486       prog->MaxAttribs = 0; /* not meaningful for compute shaders */
 487       prog->MaxAddressRegs = 0; /* not meaningful for compute shaders */
 488       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 489       prog->MaxInputComponents = 0; /* not meaningful for compute shaders */
 490       prog->MaxOutputComponents = 0; /* not meaningful for compute shaders */
 491       break;
 492    default:
 493       assert(0 && "Bad shader stage in init_program_limits()");
 494    }
 495
 496    /* Set the native limits to zero.  This implies that there is no native
 497     * support for shaders.  Let the drivers fill in the actual values.
 498     */
 499    prog->MaxNativeInstructions = 0;
 500    prog->MaxNativeAluInstructions = 0;
 501    prog->MaxNativeTexInstructions = 0;
 502    prog->MaxNativeTexIndirections = 0;
 503    prog->MaxNativeAttribs = 0;
 504    prog->MaxNativeTemps = 0;
 505    prog->MaxNativeAddressRegs = 0;
 506    prog->MaxNativeParameters = 0;
 507
 508    /* Set GLSL datatype range/precision info assuming IEEE float values.
 509     * Drivers should override these defaults as needed.
 510     */
 511    prog->MediumFloat.RangeMin = 127;
 512    prog->MediumFloat.RangeMax = 127;
 513    prog->MediumFloat.Precision = 23;
 514    prog->LowFloat = prog->HighFloat = prog->MediumFloat;
 515
 516    /* Assume ints are stored as floats for now, since this is the least-common
 517     * denominator.  The OpenGL ES spec implies (page 132) that the precision
 518     * of integer types should be 0.  Practically speaking, IEEE
 519     * single-precision floating point values can only store integers in the
 520     * range [-0x01000000, 0x01000000] without loss of precision.
 521     */
 522    prog->MediumInt.RangeMin = 24;
 523    prog->MediumInt.RangeMax = 24;
 524    prog->MediumInt.Precision = 0;
 525    prog->LowInt = prog->HighInt = prog->MediumInt;
 526
 527    prog->MaxUniformBlocks = 12;
 528    prog->MaxCombinedUniformComponents = (prog->MaxUniformComponents +
 529                                          consts->MaxUniformBlockSize / 4 *
 530                                          prog->MaxUniformBlocks);
 531
 532    prog->MaxAtomicBuffers = 0;
 533    prog->MaxAtomicCounters = 0;
 534
 535    prog->MaxShaderStorageBlocks = 8;
 536 }
 537
 538
 539 /**
 540  * Initialize fields of gl_constants (aka ctx->Const.*).
 541  * Use defaults from config.h.  The device drivers will often override
 542  * some of these values (such as number of texture units).
 543  */
 544 void
 545 _mesa_init_constants(struct gl_constants *consts, gl_api api)
 546 {
 547    int i;
 548    assert(consts);
 549
 550    /* Constants, may be overriden (usually only reduced) by device drivers */
 551    consts->MaxTextureMbytes = MAX_TEXTURE_MBYTES;
 552    consts->MaxTextureLevels = MAX_TEXTURE_LEVELS;
 553    consts->Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
 554    consts->MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
 555    consts->MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
 556    consts->MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
 557    consts->MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
 558    consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 559    consts->MaxTextureUnits = MIN2(consts->MaxTextureCoordUnits,
 560                                      consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
 561    consts->MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
 562    consts->MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
 563    consts->MaxTextureBufferSize = 65536;
 564    consts->TextureBufferOffsetAlignment = 1;
 565    consts->MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
 566    consts->SubPixelBits = SUB_PIXEL_BITS;
 567    consts->MinPointSize = MIN_POINT_SIZE;
 568    consts->MaxPointSize = MAX_POINT_SIZE;
 569    consts->MinPointSizeAA = MIN_POINT_SIZE;
 570    consts->MaxPointSizeAA = MAX_POINT_SIZE;
 571    consts->PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
 572    consts->MinLineWidth = MIN_LINE_WIDTH;
 573    consts->MaxLineWidth = MAX_LINE_WIDTH;
 574    consts->MinLineWidthAA = MIN_LINE_WIDTH;
 575    consts->MaxLineWidthAA = MAX_LINE_WIDTH;
 576    consts->LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
 577    consts->MaxClipPlanes = 6;
 578    consts->MaxLights = MAX_LIGHTS;
 579    consts->MaxShininess = 128.0;
 580    consts->MaxSpotExponent = 128.0;
 581    consts->MaxViewportWidth = 16384;
 582    consts->MaxViewportHeight = 16384;
 583    consts->MinMapBufferAlignment = 64;
 584
 585    /* Driver must override these values if ARB_viewport_array is supported. */
 586    consts->MaxViewports = 1;
 587    consts->ViewportSubpixelBits = 0;
 588    consts->ViewportBounds.Min = 0;
 589    consts->ViewportBounds.Max = 0;
 590
 591    /** GL_ARB_uniform_buffer_object */
 592    consts->MaxCombinedUniformBlocks = 36;
 593    consts->MaxUniformBufferBindings = 36;
 594    consts->MaxUniformBlockSize = 16384;
 595    consts->UniformBufferOffsetAlignment = 1;
 596
 597    /** GL_ARB_shader_storage_buffer_object */
 598    consts->MaxCombinedShaderStorageBlocks = 8;
 599    consts->MaxShaderStorageBufferBindings = 8;
 600    consts->MaxShaderStorageBlockSize = 128 * 1024 * 1024; /* 2^27 */
 601    consts->ShaderStorageBufferOffsetAlignment = 256;
 602
 603    /* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */
 604    consts->MaxUserAssignableUniformLocations =
 605       4 * MESA_SHADER_STAGES * MAX_UNIFORMS;
 606
 607    for (i = 0; i < MESA_SHADER_STAGES; i++)
 608       init_program_limits(consts, i, &consts->Program[i]);
 609
 610    consts->MaxProgramMatrices = MAX_PROGRAM_MATRICES;
 611    consts->MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
 612
 613    /* Assume that if GLSL 1.30+ (or GLSL ES 3.00+) is supported that
 614     * gl_VertexID is implemented using a native hardware register with OpenGL
 615     * semantics.
 616     */
 617    consts->VertexID_is_zero_based = false;
 618
 619    /* GL_ARB_draw_buffers */
 620    consts->MaxDrawBuffers = MAX_DRAW_BUFFERS;
 621
 622    consts->MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
 623    consts->MaxRenderbufferSize = MAX_RENDERBUFFER_SIZE;
 624
 625    consts->Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 626    consts->MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
 627    consts->MaxVarying = 16; /* old limit not to break tnl and swrast */
 628    consts->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 629    consts->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;
 630    consts->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;
 631
 632    /* Shading language version */
 633    consts->GLSLVersion = 120;
 634    _mesa_override_glsl_version(consts);
 635
 636 #ifdef DEBUG
 637    consts->GenerateTemporaryNames = true;
 638 #else
 639    consts->GenerateTemporaryNames = false;
 640 #endif
 641
 642    /* GL_ARB_framebuffer_object */
 643    consts->MaxSamples = 0;
 644
 645    /* GLSL default if NativeIntegers == FALSE */
 646    consts->UniformBooleanTrue = FLOAT_AS_UNION(1.0f).u;
 647
 648    /* GL_ARB_sync */
 649    consts->MaxServerWaitTimeout = 0x1fff7fffffffULL;
 650
 651    /* GL_EXT_provoking_vertex */
 652    consts->QuadsFollowProvokingVertexConvention = GL_TRUE;
 653
 654    /** GL_ARB_viewport_array */
 655    consts->LayerAndVPIndexProvokingVertex = GL_UNDEFINED_VERTEX;
 656
 657    /* GL_EXT_transform_feedback */
 658    consts->MaxTransformFeedbackBuffers = MAX_FEEDBACK_BUFFERS;
 659    consts->MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;
 660    consts->MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;
 661    consts->MaxVertexStreams = 1;
 662
 663    /* GL 3.2  */
 664    consts->ProfileMask = api == API_OPENGL_CORE
 665                           ? GL_CONTEXT_CORE_PROFILE_BIT
 666                           : GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
 667
 668    /* GL 4.4 */
 669    consts->MaxVertexAttribStride = 2048;
 670
 671    /** GL_EXT_gpu_shader4 */
 672    consts->MinProgramTexelOffset = -8;
 673    consts->MaxProgramTexelOffset = 7;
 674
 675    /* GL_ARB_texture_gather */
 676    consts->MinProgramTextureGatherOffset = -8;
 677    consts->MaxProgramTextureGatherOffset = 7;
 678
 679    /* GL_ARB_robustness */
 680    consts->ResetStrategy = GL_NO_RESET_NOTIFICATION_ARB;
 681
 682    /* GL_KHR_robustness */
 683    consts->RobustAccess = GL_FALSE;
 684
 685    /* ES 3.0 or ARB_ES3_compatibility */
 686    consts->MaxElementIndex = 0xffffffffu;
 687
 688    /* GL_ARB_texture_multisample */
 689    consts->MaxColorTextureSamples = 1;
 690    consts->MaxDepthTextureSamples = 1;
 691    consts->MaxIntegerSamples = 1;
 692
 693    /* GL_ARB_shader_atomic_counters */
 694    consts->MaxAtomicBufferBindings = MAX_COMBINED_ATOMIC_BUFFERS;
 695    consts->MaxAtomicBufferSize = MAX_ATOMIC_COUNTERS * ATOMIC_COUNTER_SIZE;
 696    consts->MaxCombinedAtomicBuffers = MAX_COMBINED_ATOMIC_BUFFERS;
 697    consts->MaxCombinedAtomicCounters = MAX_ATOMIC_COUNTERS;
 698
 699    /* GL_ARB_vertex_attrib_binding */
 700    consts->MaxVertexAttribRelativeOffset = 2047;
 701    consts->MaxVertexAttribBindings = MAX_VERTEX_GENERIC_ATTRIBS;
 702
 703    /* GL_ARB_compute_shader */
 704    consts->MaxComputeWorkGroupCount[0] = 65535;
 705    consts->MaxComputeWorkGroupCount[1] = 65535;
 706    consts->MaxComputeWorkGroupCount[2] = 65535;
 707    consts->MaxComputeWorkGroupSize[0] = 1024;
 708    consts->MaxComputeWorkGroupSize[1] = 1024;
 709    consts->MaxComputeWorkGroupSize[2] = 64;
 710    /* Enables compute support for GLES 3.1 if >= 128 */
 711    consts->MaxComputeWorkGroupInvocations = 0;
 712
 713    /** GL_ARB_gpu_shader5 */
 714    consts->MinFragmentInterpolationOffset = MIN_FRAGMENT_INTERPOLATION_OFFSET;
 715    consts->MaxFragmentInterpolationOffset = MAX_FRAGMENT_INTERPOLATION_OFFSET;
 716
 717    /** GL_KHR_context_flush_control */
 718    consts->ContextReleaseBehavior = GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH;
 719
 720    /** GL_ARB_tessellation_shader */
 721    consts->MaxTessGenLevel = MAX_TESS_GEN_LEVEL;
 722    consts->MaxPatchVertices = MAX_PATCH_VERTICES;
 723    consts->Program[MESA_SHADER_TESS_CTRL].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 724    consts->Program[MESA_SHADER_TESS_EVAL].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 725    consts->MaxTessPatchComponents = MAX_TESS_PATCH_COMPONENTS;
 726    consts->MaxTessControlTotalOutputComponents = MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS;
 727    consts->PrimitiveRestartForPatches = false;
 728
 729    /** GL_ARB_compute_variable_group_size */
 730    consts->MaxComputeVariableGroupSize[0] = 512;
 731    consts->MaxComputeVariableGroupSize[1] = 512;
 732    consts->MaxComputeVariableGroupSize[2] = 64;
 733    consts->MaxComputeVariableGroupInvocations = 512;
 734 }
 735
 736
 737 /**
 738  * Do some sanity checks on the limits/constants for the given context.
 739  * Only called the first time a context is bound.
 740  */
 741 static void
 742 check_context_limits(struct gl_context *ctx)
 743 {
 744    (void) ctx;
 745
 746    /* check that we don't exceed the size of various bitfields */
 747    assert(VARYING_SLOT_MAX <=
 748           (8 * sizeof(ctx->VertexProgram._Current->info.outputs_written)));
 749    assert(VARYING_SLOT_MAX <=
 750           (8 * sizeof(ctx->FragmentProgram._Current->info.inputs_read)));
 751
 752    /* shader-related checks */
 753    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
 754    assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
 755
 756    /* Texture unit checks */
 757    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits > 0);
 758    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
 759    assert(ctx->Const.MaxTextureCoordUnits > 0);
 760    assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
 761    assert(ctx->Const.MaxTextureUnits > 0);
 762    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
 763    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
 764    assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits,
 765                                              ctx->Const.MaxTextureCoordUnits));
 766    assert(ctx->Const.MaxCombinedTextureImageUnits > 0);
 767    assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
 768    assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
 769    /* number of coord units cannot be greater than number of image units */
 770    assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
 771
 772
 773    /* Texture size checks */
 774    assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
 775    assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
 776    assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
 777    assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
 778
 779    /* Texture level checks */
 780    assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
 781    assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
 782
 783    /* Max texture size should be <= max viewport size (render to texture) */
 784    assert((1U << (ctx->Const.MaxTextureLevels - 1))
 785           <= ctx->Const.MaxViewportWidth);
 786    assert((1U << (ctx->Const.MaxTextureLevels - 1))
 787           <= ctx->Const.MaxViewportHeight);
 788
 789    assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
 790
 791    /* if this fails, add more enum values to gl_buffer_index */
 792    assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);
 793
 794    /* XXX probably add more tests */
 795 }
 796
 797
 798 /**
 799  * Initialize the attribute groups in a GL context.
 800  *
 801  * \param ctx GL context.
 802  *
 803  * Initializes all the attributes, calling the respective <tt>init*</tt>
 804  * functions for the more complex data structures.
 805  */
 806 static GLboolean
 807 init_attrib_groups(struct gl_context *ctx)
 808 {
 809    assert(ctx);
 810
 811    /* Constants */
 812    _mesa_init_constants(&ctx->Const, ctx->API);
 813
 814    /* Extensions */
 815    _mesa_init_extensions(&ctx->Extensions);
 816
 817    /* Attribute Groups */
 818    _mesa_init_accum( ctx );
 819    _mesa_init_attrib( ctx );
 820    _mesa_init_bbox( ctx );
 821    _mesa_init_buffer_objects( ctx );
 822    _mesa_init_color( ctx );
 823    _mesa_init_current( ctx );
 824    _mesa_init_depth( ctx );
 825    _mesa_init_debug( ctx );
 826    _mesa_init_debug_output( ctx );
 827    _mesa_init_display_list( ctx );
 828    _mesa_init_eval( ctx );
 829    _mesa_init_fbobjects( ctx );
 830    _mesa_init_feedback( ctx );
 831    _mesa_init_fog( ctx );
 832    _mesa_init_hint( ctx );
 833    _mesa_init_image_units( ctx );
 834    _mesa_init_line( ctx );
 835    _mesa_init_lighting( ctx );
 836    _mesa_init_matrix( ctx );
 837    _mesa_init_multisample( ctx );
 838    _mesa_init_performance_monitors( ctx );
 839    _mesa_init_pipeline( ctx );
 840    _mesa_init_pixel( ctx );
 841    _mesa_init_pixelstore( ctx );
 842    _mesa_init_point( ctx );
 843    _mesa_init_polygon( ctx );
 844    _mesa_init_program( ctx );
 845    _mesa_init_queryobj( ctx );
 846    _mesa_init_sync( ctx );
 847    _mesa_init_rastpos( ctx );
 848    _mesa_init_scissor( ctx );
 849    _mesa_init_shader_state( ctx );
 850    _mesa_init_stencil( ctx );
 851    _mesa_init_transform( ctx );
 852    _mesa_init_transform_feedback( ctx );
 853    _mesa_init_varray( ctx );
 854    _mesa_init_viewport( ctx );
 855
 856    if (!_mesa_init_texture( ctx ))
 857       return GL_FALSE;
 858
 859    _mesa_init_texture_s3tc( ctx );
 860
 861    /* Miscellaneous */
 862    ctx->NewState = _NEW_ALL;
 863    ctx->NewDriverState = ~0;
 864    ctx->ErrorValue = GL_NO_ERROR;
 865    ctx->ShareGroupReset = false;
 866    ctx->varying_vp_inputs = VERT_BIT_ALL;
 867
 868    return GL_TRUE;
 869 }
 870
 871
 872 /**
 873  * Update default objects in a GL context with respect to shared state.
 874  *
 875  * \param ctx GL context.
 876  *
 877  * Removes references to old default objects, (texture objects, program
 878  * objects, etc.) and changes to reference those from the current shared
 879  * state.
 880  */
 881 static GLboolean
 882 update_default_objects(struct gl_context *ctx)
 883 {
 884    assert(ctx);
 885
 886    _mesa_update_default_objects_program(ctx);
 887    _mesa_update_default_objects_texture(ctx);
 888    _mesa_update_default_objects_buffer_objects(ctx);
 889
 890    return GL_TRUE;
 891 }
 892
 893
 894 /* XXX this is temporary and should be removed at some point in the
 895  * future when there's a reasonable expectation that the libGL library
 896  * contains the _glapi_new_nop_table() and _glapi_set_nop_handler()
 897  * functions which were added in Mesa 10.6.
 898  */
 899 #if !defined(_WIN32)
 900 /* Avoid libGL / driver ABI break */
 901 #define USE_GLAPI_NOP_FEATURES 0
 902 #else
 903 #define USE_GLAPI_NOP_FEATURES 1
 904 #endif
 905
 906
 907 /**
 908  * This function is called by the glapi no-op functions.  For each OpenGL
 909  * function/entrypoint there's a simple no-op function.  These "no-op"
 910  * functions call this function.
 911  *
 912  * If there's a current OpenGL context for the calling thread, we record a
 913  * GL_INVALID_OPERATION error.  This can happen either because the app's
 914  * calling an unsupported extension function, or calling an illegal function
 915  * (such as glClear between glBegin/glEnd).
 916  *
 917  * If there's no current OpenGL context for the calling thread, we can
 918  * print a message to stderr.
 919  *
 920  * \param name  the name of the OpenGL function
 921  */
 922 #if USE_GLAPI_NOP_FEATURES
 923 static void
 924 nop_handler(const char *name)
 925 {
 926    GET_CURRENT_CONTEXT(ctx);
 927    if (ctx) {
 928       _mesa_error(ctx, GL_INVALID_OPERATION, "%s(invalid call)", name);
 929    }
 930 #if defined(DEBUG)
 931    else if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG")) {
 932       fprintf(stderr,
 933               "GL User Error: gl%s called without a rendering context\n",
 934               name);
 935       fflush(stderr);
 936    }
 937 #endif
 938 }
 939 #endif
 940
 941
 942 /**
 943  * Special no-op glFlush, see below.
 944  */
 945 #if defined(_WIN32)
 946 static void GLAPIENTRY
 947 nop_glFlush(void)
 948 {
 949    /* don't record an error like we do in nop_handler() */
 950 }
 951 #endif
 952
 953
 954 #if !USE_GLAPI_NOP_FEATURES
 955 static int
 956 generic_nop(void)
 957 {
 958    GET_CURRENT_CONTEXT(ctx);
 959    _mesa_error(ctx, GL_INVALID_OPERATION,
 960                "unsupported function called "
 961                "(unsupported extension or deprecated function?)");
 962    return 0;
 963 }
 964 #endif
 965
 966
 967 /**
 968  * Create a new API dispatch table in which all entries point to the
 969  * generic_nop() function.  This will not work on Windows because of
 970  * the __stdcall convention which requires the callee to clean up the
 971  * call stack.  That's impossible with one generic no-op function.
 972  */
 973 struct _glapi_table *
 974 _mesa_new_nop_table(unsigned numEntries)
 975 {
 976    struct _glapi_table *table;
 977
 978 #if !USE_GLAPI_NOP_FEATURES
 979    table = malloc(numEntries * sizeof(_glapi_proc));
 980    if (table) {
 981       _glapi_proc *entry = (_glapi_proc *) table;
 982       unsigned i;
 983       for (i = 0; i < numEntries; i++) {
 984          entry[i] = (_glapi_proc) generic_nop;
 985       }
 986    }
 987 #else
 988    table = _glapi_new_nop_table(numEntries);
 989 #endif
 990    return table;
 991 }
 992
 993
 994 /**
 995  * Allocate and initialize a new dispatch table.  The table will be
 996  * populated with pointers to "no-op" functions.  In turn, the no-op
 997  * functions will call nop_handler() above.
 998  */
 999 static struct _glapi_table *
1000 alloc_dispatch_table(void)
1001 {
1002    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1003     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
1004     * Mesa we do this to accommodate different versions of libGL and various
1005     * DRI drivers.
1006     */
1007    int numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);
1008
1009    struct _glapi_table *table = _mesa_new_nop_table(numEntries);
1010
1011 #if defined(_WIN32)
1012    if (table) {
1013       /* This is a special case for Windows in the event that
1014        * wglGetProcAddress is called between glBegin/End().
1015        *
1016        * The MS opengl32.dll library apparently calls glFlush from
1017        * wglGetProcAddress().  If we're inside glBegin/End(), glFlush
1018        * will dispatch to _mesa_generic_nop() and we'll generate a
1019        * GL_INVALID_OPERATION error.
1020        *
1021        * The specific case which hits this is piglit's primitive-restart
1022        * test which calls glPrimitiveRestartNV() inside glBegin/End.  The
1023        * first time we call glPrimitiveRestartNV() Piglit's API dispatch
1024        * code will try to resolve the function by calling wglGetProcAddress.
1025        * This raises GL_INVALID_OPERATION and an assert(glGetError()==0)
1026        * will fail causing the test to fail.  By suppressing the error, the
1027        * assertion passes and the test continues.
1028        */
1029       SET_Flush(table, nop_glFlush);
1030    }
1031 #endif
1032
1033 #if USE_GLAPI_NOP_FEATURES
1034    _glapi_set_nop_handler(nop_handler);
1035 #endif
1036
1037    return table;
1038 }
1039
1040 /**
1041  * Creates a minimal dispatch table for use within glBegin()/glEnd().
1042  *
1043  * This ensures that we generate GL_INVALID_OPERATION errors from most
1044  * functions, since the set of functions that are valid within Begin/End is
1045  * very small.
1046  *
1047  * From the GL 1.0 specification section 2.6.3, "GL Commands within
1048  * Begin/End"
1049  *
1050  *     "The only GL commands that are allowed within any Begin/End pairs are
1051  *      the commands for specifying vertex coordinates, vertex color, normal
1052  *      coordinates, and texture coordinates (Vertex, Color, Index, Normal,
1053  *      TexCoord), EvalCoord and EvalPoint commands (see section 5.1),
1054  *      commands for specifying lighting material parameters (Material
1055  *      commands see section 2.12.2), display list invocation commands
1056  *      (CallList and CallLists see section 5.4), and the EdgeFlag
1057  *      command. Executing Begin after Begin has already been executed but
1058  *      before an End is issued generates the INVALID OPERATION error, as does
1059  *      executing End without a previous corresponding Begin. Executing any
1060  *      other GL command within Begin/End results in the error INVALID
1061  *      OPERATION."
1062  *
1063  * The table entries for specifying vertex attributes are set up by
1064  * install_vtxfmt() and _mesa_loopback_init_api_table(), and End() and dlists
1065  * are set by install_vtxfmt() as well.
1066  */
1067 static struct _glapi_table *
1068 create_beginend_table(const struct gl_context *ctx)
1069 {
1070    struct _glapi_table *table;
1071
1072    table = alloc_dispatch_table();
1073    if (!table)
1074       return NULL;
1075
1076    /* Fill in functions which return a value, since they should return some
1077     * specific value even if they emit a GL_INVALID_OPERATION error from them
1078     * being called within glBegin()/glEnd().
1079     */
1080 #define COPY_DISPATCH(func) SET_##func(table, GET_##func(ctx->Exec))
1081
1082    COPY_DISPATCH(GenLists);
1083    COPY_DISPATCH(IsProgram);
1084    COPY_DISPATCH(IsVertexArray);
1085    COPY_DISPATCH(IsBuffer);
1086    COPY_DISPATCH(IsEnabled);
1087    COPY_DISPATCH(IsEnabledi);
1088    COPY_DISPATCH(IsRenderbuffer);
1089    COPY_DISPATCH(IsFramebuffer);
1090    COPY_DISPATCH(CheckFramebufferStatus);
1091    COPY_DISPATCH(RenderMode);
1092    COPY_DISPATCH(GetString);
1093    COPY_DISPATCH(GetStringi);
1094    COPY_DISPATCH(GetPointerv);
1095    COPY_DISPATCH(IsQuery);
1096    COPY_DISPATCH(IsSampler);
1097    COPY_DISPATCH(IsSync);
1098    COPY_DISPATCH(IsTexture);
1099    COPY_DISPATCH(IsTransformFeedback);
1100    COPY_DISPATCH(DeleteQueries);
1101    COPY_DISPATCH(AreTexturesResident);
1102    COPY_DISPATCH(FenceSync);
1103    COPY_DISPATCH(ClientWaitSync);
1104    COPY_DISPATCH(MapBuffer);
1105    COPY_DISPATCH(UnmapBuffer);
1106    COPY_DISPATCH(MapBufferRange);
1107    COPY_DISPATCH(ObjectPurgeableAPPLE);
1108    COPY_DISPATCH(ObjectUnpurgeableAPPLE);
1109
1110    _mesa_loopback_init_api_table(ctx, table);
1111
1112    return table;
1113 }
1114
1115 void
1116 _mesa_initialize_dispatch_tables(struct gl_context *ctx)
1117 {
1118    /* Do the code-generated setup of the exec table in api_exec.c. */
1119    _mesa_initialize_exec_table(ctx);
1120
1121    if (ctx->Save)
1122       _mesa_initialize_save_table(ctx);
1123 }
1124
1125 /**
1126  * Initialize a struct gl_context struct (rendering context).
1127  *
1128  * This includes allocating all the other structs and arrays which hang off of
1129  * the context by pointers.
1130  * Note that the driver needs to pass in its dd_function_table here since
1131  * we need to at least call driverFunctions->NewTextureObject to create the
1132  * default texture objects.
1133  *
1134  * Called by _mesa_create_context().
1135  *
1136  * Performs the imports and exports callback tables initialization, and
1137  * miscellaneous one-time initializations. If no shared context is supplied one
1138  * is allocated, and increase its reference count.  Setups the GL API dispatch
1139  * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
1140  * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1141  * for debug flags.
1142  *
1143  * \param ctx the context to initialize
1144  * \param api the GL API type to create the context for
1145  * \param visual describes the visual attributes for this context or NULL to
1146  *               create a configless context
1147  * \param share_list points to context to share textures, display lists,
1148  *        etc with, or NULL
1149  * \param driverFunctions table of device driver functions for this context
1150  *        to use
1151  */
1152 GLboolean
1153 _mesa_initialize_context(struct gl_context *ctx,
1154                          gl_api api,
1155                          const struct gl_config *visual,
1156                          struct gl_context *share_list,
1157                          const struct dd_function_table *driverFunctions)
1158 {
1159    struct gl_shared_state *shared;
1160    int i;
1161
1162    assert(driverFunctions->NewTextureObject);
1163    assert(driverFunctions->FreeTextureImageBuffer);
1164
1165    ctx->API = api;
1166    ctx->DrawBuffer = NULL;
1167    ctx->ReadBuffer = NULL;
1168    ctx->WinSysDrawBuffer = NULL;
1169    ctx->WinSysReadBuffer = NULL;
1170
1171    if (visual) {
1172       ctx->Visual = *visual;
1173       ctx->HasConfig = GL_TRUE;
1174    }
1175    else {
1176       memset(&ctx->Visual, 0, sizeof ctx->Visual);
1177       ctx->HasConfig = GL_FALSE;
1178    }
1179
1180    _mesa_override_gl_version(ctx);
1181
1182    /* misc one-time initializations */
1183    one_time_init(ctx);
1184
1185    /* Plug in driver functions and context pointer here.
1186     * This is important because when we call alloc_shared_state() below
1187     * we'll call ctx->Driver.NewTextureObject() to create the default
1188     * textures.
1189     */
1190    ctx->Driver = *driverFunctions;
1191
1192    if (share_list) {
1193       /* share state with another context */
1194       shared = share_list->Shared;
1195    }
1196    else {
1197       /* allocate new, unshared state */
1198       shared = _mesa_alloc_shared_state(ctx);
1199       if (!shared)
1200          return GL_FALSE;
1201    }
1202
1203    _mesa_reference_shared_state(ctx, &ctx->Shared, shared);
1204
1205    if (!init_attrib_groups( ctx ))
1206       goto fail;
1207
1208    /* setup the API dispatch tables with all nop functions */
1209    ctx->OutsideBeginEnd = alloc_dispatch_table();
1210    if (!ctx->OutsideBeginEnd)
1211       goto fail;
1212    ctx->Exec = ctx->OutsideBeginEnd;
1213    ctx->CurrentDispatch = ctx->OutsideBeginEnd;
1214
1215    ctx->FragmentProgram._MaintainTexEnvProgram
1216       = (getenv("MESA_TEX_PROG") != NULL);
1217
1218    ctx->VertexProgram._MaintainTnlProgram
1219       = (getenv("MESA_TNL_PROG") != NULL);
1220    if (ctx->VertexProgram._MaintainTnlProgram) {
1221       /* this is required... */
1222       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1223    }
1224
1225    /* Mesa core handles all the formats that mesa core knows about.
1226     * Drivers will want to override this list with just the formats
1227     * they can handle, and confirm that appropriate fallbacks exist in
1228     * _mesa_choose_tex_format().
1229     */
1230    memset(&ctx->TextureFormatSupported, GL_TRUE,
1231           sizeof(ctx->TextureFormatSupported));
1232
1233    ctx->Cache = disk_cache_create();
1234
1235    switch (ctx->API) {
1236    case API_OPENGL_COMPAT:
1237       ctx->BeginEnd = create_beginend_table(ctx);
1238       ctx->Save = alloc_dispatch_table();
1239       if (!ctx->BeginEnd || !ctx->Save)
1240          goto fail;
1241
1242       /* fall-through */
1243    case API_OPENGL_CORE:
1244       break;
1245    case API_OPENGLES:
1246       /**
1247        * GL_OES_texture_cube_map says
1248        * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
1249        */
1250       for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1251          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
1252          texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
1253          texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
1254          texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
1255          texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1256          texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1257          texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1258       }
1259       break;
1260    case API_OPENGLES2:
1261       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1262       ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
1263       break;
1264    }
1265
1266    ctx->FirstTimeCurrent = GL_TRUE;
1267
1268    return GL_TRUE;
1269
1270 fail:
1271    _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1272    free(ctx->BeginEnd);
1273    free(ctx->OutsideBeginEnd);
1274    free(ctx->Save);
1275    ralloc_free(ctx->Cache);
1276    return GL_FALSE;
1277 }
1278
1279
1280 /**
1281  * Free the data associated with the given context.
1282  *
1283  * But doesn't free the struct gl_context struct itself.
1284  *
1285  * \sa _mesa_initialize_context() and init_attrib_groups().
1286  */
1287 void
1288 _mesa_free_context_data( struct gl_context *ctx )
1289 {
1290    if (!_mesa_get_current_context()){
1291       /* No current context, but we may need one in order to delete
1292        * texture objs, etc.  So temporarily bind the context now.
1293        */
1294       _mesa_make_current(ctx, NULL, NULL);
1295    }
1296
1297    /* unreference WinSysDraw/Read buffers */
1298    _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
1299    _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
1300    _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
1301    _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
1302
1303    _mesa_reference_program(ctx, &ctx->VertexProgram.Current, NULL);
1304    _mesa_reference_program(ctx, &ctx->VertexProgram._Current, NULL);
1305    _mesa_reference_program(ctx, &ctx->VertexProgram._TnlProgram, NULL);
1306
1307    _mesa_reference_program(ctx, &ctx->TessCtrlProgram._Current, NULL);
1308    _mesa_reference_program(ctx, &ctx->TessEvalProgram._Current, NULL);
1309    _mesa_reference_program(ctx, &ctx->GeometryProgram._Current, NULL);
1310
1311    _mesa_reference_program(ctx, &ctx->FragmentProgram.Current, NULL);
1312    _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, NULL);
1313    _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
1314
1315    _mesa_reference_vao(ctx, &ctx->Array.VAO, NULL);
1316    _mesa_reference_vao(ctx, &ctx->Array.DefaultVAO, NULL);
1317
1318    _mesa_free_attrib_data(ctx);
1319    _mesa_free_buffer_objects(ctx);
1320    _mesa_free_eval_data( ctx );
1321    _mesa_free_texture_data( ctx );
1322    _mesa_free_matrix_data( ctx );
1323    _mesa_free_pipeline_data(ctx);
1324    _mesa_free_program_data(ctx);
1325    _mesa_free_shader_state(ctx);
1326    _mesa_free_queryobj_data(ctx);
1327    _mesa_free_sync_data(ctx);
1328    _mesa_free_varray_data(ctx);
1329    _mesa_free_transform_feedback(ctx);
1330    _mesa_free_performance_monitors(ctx);
1331
1332    _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
1333    _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
1334    _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
1335    _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
1336
1337    /* free dispatch tables */
1338    free(ctx->BeginEnd);
1339    free(ctx->OutsideBeginEnd);
1340    free(ctx->Save);
1341    free(ctx->ContextLost);
1342
1343    ralloc_free(ctx->Cache);
1344
1345    /* Shared context state (display lists, textures, etc) */
1346    _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1347
1348    /* needs to be after freeing shared state */
1349    _mesa_free_display_list_data(ctx);
1350
1351    _mesa_free_errors_data(ctx);
1352
1353    free((void *)ctx->Extensions.String);
1354
1355    free(ctx->VersionString);
1356
1357    /* unbind the context if it's currently bound */
1358    if (ctx == _mesa_get_current_context()) {
1359       _mesa_make_current(NULL, NULL, NULL);
1360    }
1361 }
1362
1363
1364 /**
1365  * Destroy a struct gl_context structure.
1366  *
1367  * \param ctx GL context.
1368  *
1369  * Calls _mesa_free_context_data() and frees the gl_context object itself.
1370  */
1371 void
1372 _mesa_destroy_context( struct gl_context *ctx )
1373 {
1374    if (ctx) {
1375       _mesa_free_context_data(ctx);
1376       free( (void *) ctx );
1377    }
1378 }
1379
1380
1381 /**
1382  * Copy attribute groups from one context to another.
1383  *
1384  * \param src source context
1385  * \param dst destination context
1386  * \param mask bitwise OR of GL_*_BIT flags
1387  *
1388  * According to the bits specified in \p mask, copies the corresponding
1389  * attributes from \p src into \p dst.  For many of the attributes a simple \c
1390  * memcpy is not enough due to the existence of internal pointers in their data
1391  * structures.
1392  */
1393 void
1394 _mesa_copy_context( const struct gl_context *src, struct gl_context *dst,
1395                     GLuint mask )
1396 {
1397    if (mask & GL_ACCUM_BUFFER_BIT) {
1398       /* OK to memcpy */
1399       dst->Accum = src->Accum;
1400    }
1401    if (mask & GL_COLOR_BUFFER_BIT) {
1402       /* OK to memcpy */
1403       dst->Color = src->Color;
1404    }
1405    if (mask & GL_CURRENT_BIT) {
1406       /* OK to memcpy */
1407       dst->Current = src->Current;
1408    }
1409    if (mask & GL_DEPTH_BUFFER_BIT) {
1410       /* OK to memcpy */
1411       dst->Depth = src->Depth;
1412    }
1413    if (mask & GL_ENABLE_BIT) {
1414       /* no op */
1415    }
1416    if (mask & GL_EVAL_BIT) {
1417       /* OK to memcpy */
1418       dst->Eval = src->Eval;
1419    }
1420    if (mask & GL_FOG_BIT) {
1421       /* OK to memcpy */
1422       dst->Fog = src->Fog;
1423    }
1424    if (mask & GL_HINT_BIT) {
1425       /* OK to memcpy */
1426       dst->Hint = src->Hint;
1427    }
1428    if (mask & GL_LIGHTING_BIT) {
1429       /* OK to memcpy */
1430       dst->Light = src->Light;
1431    }
1432    if (mask & GL_LINE_BIT) {
1433       /* OK to memcpy */
1434       dst->Line = src->Line;
1435    }
1436    if (mask & GL_LIST_BIT) {
1437       /* OK to memcpy */
1438       dst->List = src->List;
1439    }
1440    if (mask & GL_PIXEL_MODE_BIT) {
1441       /* OK to memcpy */
1442       dst->Pixel = src->Pixel;
1443    }
1444    if (mask & GL_POINT_BIT) {
1445       /* OK to memcpy */
1446       dst->Point = src->Point;
1447    }
1448    if (mask & GL_POLYGON_BIT) {
1449       /* OK to memcpy */
1450       dst->Polygon = src->Polygon;
1451    }
1452    if (mask & GL_POLYGON_STIPPLE_BIT) {
1453       /* Use loop instead of memcpy due to problem with Portland Group's
1454        * C compiler.  Reported by John Stone.
1455        */
1456       GLuint i;
1457       for (i = 0; i < 32; i++) {
1458          dst->PolygonStipple[i] = src->PolygonStipple[i];
1459       }
1460    }
1461    if (mask & GL_SCISSOR_BIT) {
1462       /* OK to memcpy */
1463       dst->Scissor = src->Scissor;
1464    }
1465    if (mask & GL_STENCIL_BUFFER_BIT) {
1466       /* OK to memcpy */
1467       dst->Stencil = src->Stencil;
1468    }
1469    if (mask & GL_TEXTURE_BIT) {
1470       /* Cannot memcpy because of pointers */
1471       _mesa_copy_texture_state(src, dst);
1472    }
1473    if (mask & GL_TRANSFORM_BIT) {
1474       /* OK to memcpy */
1475       dst->Transform = src->Transform;
1476    }
1477    if (mask & GL_VIEWPORT_BIT) {
1478       unsigned i;
1479       for (i = 0; i < src->Const.MaxViewports; i++) {
1480          /* OK to memcpy */
1481          dst->ViewportArray[i] = src->ViewportArray[i];
1482       }
1483    }
1484
1485    /* XXX FIXME:  Call callbacks?
1486     */
1487    dst->NewState = _NEW_ALL;
1488    dst->NewDriverState = ~0;
1489 }
1490
1491
1492 /**
1493  * Check if the given context can render into the given framebuffer
1494  * by checking visual attributes.
1495  *
1496  * \return GL_TRUE if compatible, GL_FALSE otherwise.
1497  */
1498 static GLboolean
1499 check_compatible(const struct gl_context *ctx,
1500                  const struct gl_framebuffer *buffer)
1501 {
1502    const struct gl_config *ctxvis = &ctx->Visual;
1503    const struct gl_config *bufvis = &buffer->Visual;
1504
1505    if (buffer == _mesa_get_incomplete_framebuffer())
1506       return GL_TRUE;
1507
1508 #define check_component(foo)           \
1509    if (ctxvis->foo && bufvis->foo &&   \
1510        ctxvis->foo != bufvis->foo)     \
1511       return GL_FALSE
1512
1513    check_component(redMask);
1514    check_component(greenMask);
1515    check_component(blueMask);
1516    check_component(depthBits);
1517    check_component(stencilBits);
1518
1519 #undef check_component
1520
1521    return GL_TRUE;
1522 }
1523
1524
1525 /**
1526  * Check if the viewport/scissor size has not yet been initialized.
1527  * Initialize the size if the given width and height are non-zero.
1528  */
1529 void
1530 _mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
1531 {
1532    if (!ctx->ViewportInitialized && width > 0 && height > 0) {
1533       unsigned i;
1534
1535       /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
1536        * potential infinite recursion.
1537        */
1538       ctx->ViewportInitialized = GL_TRUE;
1539
1540       /* Note: ctx->Const.MaxViewports may not have been set by the driver
1541        * yet, so just initialize all of them.
1542        */
1543       for (i = 0; i < MAX_VIEWPORTS; i++) {
1544          _mesa_set_viewport(ctx, i, 0, 0, width, height);
1545          _mesa_set_scissor(ctx, i, 0, 0, width, height);
1546       }
1547    }
1548 }
1549
1550 static void
1551 handle_first_current(struct gl_context *ctx)
1552 {
1553    if (ctx->Version == 0 || !ctx->DrawBuffer) {
1554       /* probably in the process of tearing down the context */
1555       return;
1556    }
1557
1558    ctx->Extensions.String = _mesa_make_extension_string(ctx);
1559
1560    check_context_limits(ctx);
1561
1562    /* According to GL_MESA_configless_context the default value of
1563     * glDrawBuffers depends on the config of the first surface it is bound to.
1564     * For GLES it is always GL_BACK which has a magic interpretation */
1565    if (!ctx->HasConfig && _mesa_is_desktop_gl(ctx)) {
1566       if (ctx->DrawBuffer != _mesa_get_incomplete_framebuffer()) {
1567          GLenum buffer;
1568
1569          if (ctx->DrawBuffer->Visual.doubleBufferMode)
1570             buffer = GL_BACK;
1571          else
1572             buffer = GL_FRONT;
1573
1574          _mesa_drawbuffers(ctx, ctx->DrawBuffer, 1, &buffer,
1575                            NULL /* destMask */);
1576       }
1577
1578       if (ctx->ReadBuffer != _mesa_get_incomplete_framebuffer()) {
1579          gl_buffer_index bufferIndex;
1580          GLenum buffer;
1581
1582          if (ctx->ReadBuffer->Visual.doubleBufferMode) {
1583             buffer = GL_BACK;
1584             bufferIndex = BUFFER_BACK_LEFT;
1585          }
1586          else {
1587             buffer = GL_FRONT;
1588             bufferIndex = BUFFER_FRONT_LEFT;
1589          }
1590
1591          _mesa_readbuffer(ctx, ctx->ReadBuffer, buffer, bufferIndex);
1592       }
1593    }
1594
1595    /* We can use this to help debug user's problems.  Tell them to set
1596     * the MESA_INFO env variable before running their app.  Then the
1597     * first time each context is made current we'll print some useful
1598     * information.
1599     */
1600    if (getenv("MESA_INFO")) {
1601       _mesa_print_info(ctx);
1602    }
1603 }
1604
1605 /**
1606  * Bind the given context to the given drawBuffer and readBuffer and
1607  * make it the current context for the calling thread.
1608  * We'll render into the drawBuffer and read pixels from the
1609  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1610  *
1611  * We check that the context's and framebuffer's visuals are compatible
1612  * and return immediately if they're not.
1613  *
1614  * \param newCtx  the new GL context. If NULL then there will be no current GL
1615  *                context.
1616  * \param drawBuffer  the drawing framebuffer
1617  * \param readBuffer  the reading framebuffer
1618  */
1619 GLboolean
1620 _mesa_make_current( struct gl_context *newCtx,
1621                     struct gl_framebuffer *drawBuffer,
1622                     struct gl_framebuffer *readBuffer )
1623 {
1624    GET_CURRENT_CONTEXT(curCtx);
1625
1626    if (MESA_VERBOSE & VERBOSE_API)
1627       _mesa_debug(newCtx, "_mesa_make_current()\n");
1628
1629    /* Check that the context's and framebuffer's visuals are compatible.
1630     */
1631    if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1632       if (!check_compatible(newCtx, drawBuffer)) {
1633          _mesa_warning(newCtx,
1634               "MakeCurrent: incompatible visuals for context and drawbuffer");
1635          return GL_FALSE;
1636       }
1637    }
1638    if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1639       if (!check_compatible(newCtx, readBuffer)) {
1640          _mesa_warning(newCtx,
1641               "MakeCurrent: incompatible visuals for context and readbuffer");
1642          return GL_FALSE;
1643       }
1644    }
1645
1646    if (curCtx &&
1647        (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) &&
1648        /* make sure this context is valid for flushing */
1649        curCtx != newCtx &&
1650        curCtx->Const.ContextReleaseBehavior ==
1651        GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH)
1652       _mesa_flush(curCtx);
1653
1654    /* We used to call _glapi_check_multithread() here.  Now do it in drivers */
1655    _glapi_set_context((void *) newCtx);
1656    assert(_mesa_get_current_context() == newCtx);
1657
1658    if (!newCtx) {
1659       _glapi_set_dispatch(NULL);  /* none current */
1660       if (curCtx) {
1661          _mesa_reference_framebuffer(&curCtx->WinSysDrawBuffer, NULL);
1662          _mesa_reference_framebuffer(&curCtx->WinSysReadBuffer, NULL);
1663       }
1664    }
1665    else {
1666       _glapi_set_dispatch(newCtx->CurrentDispatch);
1667
1668       if (drawBuffer && readBuffer) {
1669          assert(_mesa_is_winsys_fbo(drawBuffer));
1670          assert(_mesa_is_winsys_fbo(readBuffer));
1671          _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1672          _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1673
1674          /*
1675           * Only set the context's Draw/ReadBuffer fields if they're NULL
1676           * or not bound to a user-created FBO.
1677           */
1678          if (!newCtx->DrawBuffer || _mesa_is_winsys_fbo(newCtx->DrawBuffer)) {
1679             _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1680             /* Update the FBO's list of drawbuffers/renderbuffers.
1681              * For winsys FBOs this comes from the GL state (which may have
1682              * changed since the last time this FBO was bound).
1683              */
1684             _mesa_update_draw_buffers(newCtx);
1685          }
1686          if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) {
1687             _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1688             /* In _mesa_initialize_window_framebuffer, for single-buffered
1689              * visuals, the ColorReadBuffer is set to be GL_FRONT, even with
1690              * GLES contexts. When calling read_buffer, we verify we are reading
1691              * from GL_BACK in is_legal_es3_readbuffer_enum.  But the default is
1692              * incorrect, and certain dEQP tests check this.  So fix it here.
1693              */
1694             if (_mesa_is_gles(newCtx) &&
1695                !newCtx->ReadBuffer->Visual.doubleBufferMode)
1696                if (newCtx->ReadBuffer->ColorReadBuffer == GL_FRONT)
1697                   newCtx->ReadBuffer->ColorReadBuffer = GL_BACK;
1698          }
1699
1700          /* XXX only set this flag if we're really changing the draw/read
1701           * framebuffer bindings.
1702           */
1703          newCtx->NewState |= _NEW_BUFFERS;
1704
1705          _mesa_check_init_viewport(newCtx,
1706                                    drawBuffer->Width, drawBuffer->Height);
1707       }
1708
1709       if (newCtx->FirstTimeCurrent) {
1710          handle_first_current(newCtx);
1711          newCtx->FirstTimeCurrent = GL_FALSE;
1712       }
1713    }
1714
1715    return GL_TRUE;
1716 }
1717
1718
1719 /**
1720  * Make context 'ctx' share the display lists, textures and programs
1721  * that are associated with 'ctxToShare'.
1722  * Any display lists, textures or programs associated with 'ctx' will
1723  * be deleted if nobody else is sharing them.
1724  */
1725 GLboolean
1726 _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
1727 {
1728    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1729       struct gl_shared_state *oldShared = NULL;
1730
1731       /* save ref to old state to prevent it from being deleted immediately */
1732       _mesa_reference_shared_state(ctx, &oldShared, ctx->Shared);
1733
1734       /* update ctx's Shared pointer */
1735       _mesa_reference_shared_state(ctx, &ctx->Shared, ctxToShare->Shared);
1736
1737       update_default_objects(ctx);
1738
1739       /* release the old shared state */
1740       _mesa_reference_shared_state(ctx, &oldShared, NULL);
1741
1742       return GL_TRUE;
1743    }
1744    else {
1745       return GL_FALSE;
1746    }
1747 }
1748
1749
1750
1751 /**
1752  * \return pointer to the current GL context for this thread.
1753  *
1754  * Calls _glapi_get_context(). This isn't the fastest way to get the current
1755  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
1756  * context.h.
1757  */
1758 struct gl_context *
1759 _mesa_get_current_context( void )
1760 {
1761    return (struct gl_context *) _glapi_get_context();
1762 }
1763
1764
1765 /**
1766  * Get context's current API dispatch table.
1767  *
1768  * It'll either be the immediate-mode execute dispatcher or the display list
1769  * compile dispatcher.
1770  *
1771  * \param ctx GL context.
1772  *
1773  * \return pointer to dispatch_table.
1774  *
1775  * Simply returns __struct gl_contextRec::CurrentDispatch.
1776  */
1777 struct _glapi_table *
1778 _mesa_get_dispatch(struct gl_context *ctx)
1779 {
1780    return ctx->CurrentDispatch;
1781 }
1782
1783 /*@}*/
1784
1785
1786 /**********************************************************************/
1787 /** \name Miscellaneous functions                                     */
1788 /**********************************************************************/
1789 /*@{*/
1790
1791 /**
1792  * Record an error.
1793  *
1794  * \param ctx GL context.
1795  * \param error error code.
1796  *
1797  * Records the given error code and call the driver's dd_function_table::Error
1798  * function if defined.
1799  *
1800  * \sa
1801  * This is called via _mesa_error().
1802  */
1803 void
1804 _mesa_record_error(struct gl_context *ctx, GLenum error)
1805 {
1806    if (!ctx)
1807       return;
1808
1809    if (ctx->ErrorValue == GL_NO_ERROR) {
1810       ctx->ErrorValue = error;
1811    }
1812 }
1813
1814
1815 /**
1816  * Flush commands and wait for completion.
1817  */
1818 void
1819 _mesa_finish(struct gl_context *ctx)
1820 {
1821    FLUSH_VERTICES( ctx, 0 );
1822    FLUSH_CURRENT( ctx, 0 );
1823    if (ctx->Driver.Finish) {
1824       ctx->Driver.Finish(ctx);
1825    }
1826 }
1827
1828
1829 /**
1830  * Flush commands.
1831  */
1832 void
1833 _mesa_flush(struct gl_context *ctx)
1834 {
1835    FLUSH_VERTICES( ctx, 0 );
1836    FLUSH_CURRENT( ctx, 0 );
1837    if (ctx->Driver.Flush) {
1838       ctx->Driver.Flush(ctx);
1839    }
1840 }
1841
1842
1843
1844 /**
1845  * Execute glFinish().
1846  *
1847  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1848  * dd_function_table::Finish driver callback, if not NULL.
1849  */
1850 void GLAPIENTRY
1851 _mesa_Finish(void)
1852 {
1853    GET_CURRENT_CONTEXT(ctx);
1854    ASSERT_OUTSIDE_BEGIN_END(ctx);
1855    _mesa_finish(ctx);
1856 }
1857
1858
1859 /**
1860  * Execute glFlush().
1861  *
1862  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1863  * dd_function_table::Flush driver callback, if not NULL.
1864  */
1865 void GLAPIENTRY
1866 _mesa_Flush(void)
1867 {
1868    GET_CURRENT_CONTEXT(ctx);
1869    ASSERT_OUTSIDE_BEGIN_END(ctx);
1870    _mesa_flush(ctx);
1871 }
1872
1873
1874
1875
1876 /*@}*/