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