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->MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
 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.MaxTextureSize <= (1 << (MAX_TEXTURE_LEVELS - 1)));
 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(ctx->Const.MaxTextureSize <= ctx->Const.MaxViewportWidth);
 796    assert(ctx->Const.MaxTextureSize <= ctx->Const.MaxViewportHeight);
 797
 798    assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
 799
 800    /* if this fails, add more enum values to gl_buffer_index */
 801    assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);
 802
 803    /* XXX probably add more tests */
 804 }
 805
 806
 807 /**
 808  * Initialize the attribute groups in a GL context.
 809  *
 810  * \param ctx GL context.
 811  *
 812  * Initializes all the attributes, calling the respective <tt>init*</tt>
 813  * functions for the more complex data structures.
 814  */
 815 static GLboolean
 816 init_attrib_groups(struct gl_context *ctx)
 817 {
 818    assert(ctx);
 819
 820    /* Constants */
 821    _mesa_init_constants(&ctx->Const, ctx->API);
 822
 823    /* Extensions */
 824    _mesa_init_extensions(&ctx->Extensions);
 825
 826    /* Attribute Groups */
 827    _mesa_init_accum( ctx );
 828    _mesa_init_attrib( ctx );
 829    _mesa_init_bbox( ctx );
 830    _mesa_init_buffer_objects( ctx );
 831    _mesa_init_color( ctx );
 832    _mesa_init_conservative_raster( ctx );
 833    _mesa_init_current( ctx );
 834    _mesa_init_depth( ctx );
 835    _mesa_init_debug( ctx );
 836    _mesa_init_debug_output( ctx );
 837    _mesa_init_display_list( ctx );
 838    _mesa_init_eval( ctx );
 839    _mesa_init_fbobjects( ctx );
 840    _mesa_init_feedback( ctx );
 841    _mesa_init_fog( ctx );
 842    _mesa_init_hint( ctx );
 843    _mesa_init_image_units( ctx );
 844    _mesa_init_line( ctx );
 845    _mesa_init_lighting( ctx );
 846    _mesa_init_matrix( ctx );
 847    _mesa_init_multisample( ctx );
 848    _mesa_init_performance_monitors( ctx );
 849    _mesa_init_performance_queries( ctx );
 850    _mesa_init_pipeline( ctx );
 851    _mesa_init_pixel( ctx );
 852    _mesa_init_pixelstore( ctx );
 853    _mesa_init_point( ctx );
 854    _mesa_init_polygon( ctx );
 855    _mesa_init_program( ctx );
 856    _mesa_init_queryobj( ctx );
 857    _mesa_init_sync( ctx );
 858    _mesa_init_rastpos( ctx );
 859    _mesa_init_scissor( ctx );
 860    _mesa_init_shader_state( ctx );
 861    _mesa_init_stencil( ctx );
 862    _mesa_init_transform( ctx );
 863    _mesa_init_transform_feedback( ctx );
 864    _mesa_init_varray( ctx );
 865    _mesa_init_viewport( ctx );
 866    _mesa_init_resident_handles( ctx );
 867
 868    if (!_mesa_init_texture( ctx ))
 869       return GL_FALSE;
 870
 871    /* Miscellaneous */
 872    ctx->TileRasterOrderIncreasingX = GL_TRUE;
 873    ctx->TileRasterOrderIncreasingY = GL_TRUE;
 874    ctx->NewState = _NEW_ALL;
 875    ctx->NewDriverState = ~0;
 876    ctx->ErrorValue = GL_NO_ERROR;
 877    ctx->ShareGroupReset = false;
 878    ctx->varying_vp_inputs = VERT_BIT_ALL;
 879
 880    return GL_TRUE;
 881 }
 882
 883
 884 /**
 885  * Update default objects in a GL context with respect to shared state.
 886  *
 887  * \param ctx GL context.
 888  *
 889  * Removes references to old default objects, (texture objects, program
 890  * objects, etc.) and changes to reference those from the current shared
 891  * state.
 892  */
 893 static GLboolean
 894 update_default_objects(struct gl_context *ctx)
 895 {
 896    assert(ctx);
 897
 898    _mesa_update_default_objects_program(ctx);
 899    _mesa_update_default_objects_texture(ctx);
 900    _mesa_update_default_objects_buffer_objects(ctx);
 901
 902    return GL_TRUE;
 903 }
 904
 905
 906 /* XXX this is temporary and should be removed at some point in the
 907  * future when there's a reasonable expectation that the libGL library
 908  * contains the _glapi_new_nop_table() and _glapi_set_nop_handler()
 909  * functions which were added in Mesa 10.6.
 910  */
 911 #if !defined(_WIN32)
 912 /* Avoid libGL / driver ABI break */
 913 #define USE_GLAPI_NOP_FEATURES 0
 914 #else
 915 #define USE_GLAPI_NOP_FEATURES 1
 916 #endif
 917
 918
 919 /**
 920  * This function is called by the glapi no-op functions.  For each OpenGL
 921  * function/entrypoint there's a simple no-op function.  These "no-op"
 922  * functions call this function.
 923  *
 924  * If there's a current OpenGL context for the calling thread, we record a
 925  * GL_INVALID_OPERATION error.  This can happen either because the app's
 926  * calling an unsupported extension function, or calling an illegal function
 927  * (such as glClear between glBegin/glEnd).
 928  *
 929  * If there's no current OpenGL context for the calling thread, we can
 930  * print a message to stderr.
 931  *
 932  * \param name  the name of the OpenGL function
 933  */
 934 #if USE_GLAPI_NOP_FEATURES
 935 static void
 936 nop_handler(const char *name)
 937 {
 938    GET_CURRENT_CONTEXT(ctx);
 939    if (ctx) {
 940       _mesa_error(ctx, GL_INVALID_OPERATION, "%s(invalid call)", name);
 941    }
 942 #ifndef NDEBUG
 943    else if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG")) {
 944       fprintf(stderr,
 945               "GL User Error: gl%s called without a rendering context\n",
 946               name);
 947       fflush(stderr);
 948    }
 949 #endif
 950 }
 951 #endif
 952
 953
 954 /**
 955  * Special no-op glFlush, see below.
 956  */
 957 #if defined(_WIN32)
 958 static void GLAPIENTRY
 959 nop_glFlush(void)
 960 {
 961    /* don't record an error like we do in nop_handler() */
 962 }
 963 #endif
 964
 965
 966 #if !USE_GLAPI_NOP_FEATURES
 967 static int
 968 generic_nop(void)
 969 {
 970    GET_CURRENT_CONTEXT(ctx);
 971    _mesa_error(ctx, GL_INVALID_OPERATION,
 972                "unsupported function called "
 973                "(unsupported extension or deprecated function?)");
 974    return 0;
 975 }
 976 #endif
 977
 978
 979 /**
 980  * Create a new API dispatch table in which all entries point to the
 981  * generic_nop() function.  This will not work on Windows because of
 982  * the __stdcall convention which requires the callee to clean up the
 983  * call stack.  That's impossible with one generic no-op function.
 984  */
 985 struct _glapi_table *
 986 _mesa_new_nop_table(unsigned numEntries)
 987 {
 988    struct _glapi_table *table;
 989
 990 #if !USE_GLAPI_NOP_FEATURES
 991    table = malloc(numEntries * sizeof(_glapi_proc));
 992    if (table) {
 993       _glapi_proc *entry = (_glapi_proc *) table;
 994       unsigned i;
 995       for (i = 0; i < numEntries; i++) {
 996          entry[i] = (_glapi_proc) generic_nop;
 997       }
 998    }
 999 #else
1000    table = _glapi_new_nop_table(numEntries);
1001 #endif
1002    return table;
1003 }
1004
1005
1006 /**
1007  * Allocate and initialize a new dispatch table.  The table will be
1008  * populated with pointers to "no-op" functions.  In turn, the no-op
1009  * functions will call nop_handler() above.
1010  */
1011 struct _glapi_table *
1012 _mesa_alloc_dispatch_table(void)
1013 {
1014    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1015     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
1016     * Mesa we do this to accommodate different versions of libGL and various
1017     * DRI drivers.
1018     */
1019    int numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);
1020
1021    struct _glapi_table *table = _mesa_new_nop_table(numEntries);
1022
1023 #if defined(_WIN32)
1024    if (table) {
1025       /* This is a special case for Windows in the event that
1026        * wglGetProcAddress is called between glBegin/End().
1027        *
1028        * The MS opengl32.dll library apparently calls glFlush from
1029        * wglGetProcAddress().  If we're inside glBegin/End(), glFlush
1030        * will dispatch to _mesa_generic_nop() and we'll generate a
1031        * GL_INVALID_OPERATION error.
1032        *
1033        * The specific case which hits this is piglit's primitive-restart
1034        * test which calls glPrimitiveRestartNV() inside glBegin/End.  The
1035        * first time we call glPrimitiveRestartNV() Piglit's API dispatch
1036        * code will try to resolve the function by calling wglGetProcAddress.
1037        * This raises GL_INVALID_OPERATION and an assert(glGetError()==0)
1038        * will fail causing the test to fail.  By suppressing the error, the
1039        * assertion passes and the test continues.
1040        */
1041       SET_Flush(table, nop_glFlush);
1042    }
1043 #endif
1044
1045 #if USE_GLAPI_NOP_FEATURES
1046    _glapi_set_nop_handler(nop_handler);
1047 #endif
1048
1049    return table;
1050 }
1051
1052 /**
1053  * Creates a minimal dispatch table for use within glBegin()/glEnd().
1054  *
1055  * This ensures that we generate GL_INVALID_OPERATION errors from most
1056  * functions, since the set of functions that are valid within Begin/End is
1057  * very small.
1058  *
1059  * From the GL 1.0 specification section 2.6.3, "GL Commands within
1060  * Begin/End"
1061  *
1062  *     "The only GL commands that are allowed within any Begin/End pairs are
1063  *      the commands for specifying vertex coordinates, vertex color, normal
1064  *      coordinates, and texture coordinates (Vertex, Color, Index, Normal,
1065  *      TexCoord), EvalCoord and EvalPoint commands (see section 5.1),
1066  *      commands for specifying lighting material parameters (Material
1067  *      commands see section 2.12.2), display list invocation commands
1068  *      (CallList and CallLists see section 5.4), and the EdgeFlag
1069  *      command. Executing Begin after Begin has already been executed but
1070  *      before an End is issued generates the INVALID OPERATION error, as does
1071  *      executing End without a previous corresponding Begin. Executing any
1072  *      other GL command within Begin/End results in the error INVALID
1073  *      OPERATION."
1074  *
1075  * The table entries for specifying vertex attributes are set up by
1076  * install_vtxfmt() and _mesa_loopback_init_api_table(), and End() and dlists
1077  * are set by install_vtxfmt() as well.
1078  */
1079 static struct _glapi_table *
1080 create_beginend_table(const struct gl_context *ctx)
1081 {
1082    struct _glapi_table *table;
1083
1084    table = _mesa_alloc_dispatch_table();
1085    if (!table)
1086       return NULL;
1087
1088    /* Fill in functions which return a value, since they should return some
1089     * specific value even if they emit a GL_INVALID_OPERATION error from them
1090     * being called within glBegin()/glEnd().
1091     */
1092 #define COPY_DISPATCH(func) SET_##func(table, GET_##func(ctx->Exec))
1093
1094    COPY_DISPATCH(GenLists);
1095    COPY_DISPATCH(IsProgram);
1096    COPY_DISPATCH(IsVertexArray);
1097    COPY_DISPATCH(IsBuffer);
1098    COPY_DISPATCH(IsEnabled);
1099    COPY_DISPATCH(IsEnabledi);
1100    COPY_DISPATCH(IsRenderbuffer);
1101    COPY_DISPATCH(IsFramebuffer);
1102    COPY_DISPATCH(CheckFramebufferStatus);
1103    COPY_DISPATCH(RenderMode);
1104    COPY_DISPATCH(GetString);
1105    COPY_DISPATCH(GetStringi);
1106    COPY_DISPATCH(GetPointerv);
1107    COPY_DISPATCH(IsQuery);
1108    COPY_DISPATCH(IsSampler);
1109    COPY_DISPATCH(IsSync);
1110    COPY_DISPATCH(IsTexture);
1111    COPY_DISPATCH(IsTransformFeedback);
1112    COPY_DISPATCH(DeleteQueries);
1113    COPY_DISPATCH(AreTexturesResident);
1114    COPY_DISPATCH(FenceSync);
1115    COPY_DISPATCH(ClientWaitSync);
1116    COPY_DISPATCH(MapBuffer);
1117    COPY_DISPATCH(UnmapBuffer);
1118    COPY_DISPATCH(MapBufferRange);
1119    COPY_DISPATCH(ObjectPurgeableAPPLE);
1120    COPY_DISPATCH(ObjectUnpurgeableAPPLE);
1121
1122    _mesa_loopback_init_api_table(ctx, table);
1123
1124    return table;
1125 }
1126
1127 void
1128 _mesa_initialize_dispatch_tables(struct gl_context *ctx)
1129 {
1130    /* Do the code-generated setup of the exec table in api_exec.c. */
1131    _mesa_initialize_exec_table(ctx);
1132
1133    if (ctx->Save)
1134       _mesa_initialize_save_table(ctx);
1135 }
1136
1137 /**
1138  * Initialize a struct gl_context struct (rendering context).
1139  *
1140  * This includes allocating all the other structs and arrays which hang off of
1141  * the context by pointers.
1142  * Note that the driver needs to pass in its dd_function_table here since
1143  * we need to at least call driverFunctions->NewTextureObject to create the
1144  * default texture objects.
1145  *
1146  * Called by _mesa_create_context().
1147  *
1148  * Performs the imports and exports callback tables initialization, and
1149  * miscellaneous one-time initializations. If no shared context is supplied one
1150  * is allocated, and increase its reference count.  Setups the GL API dispatch
1151  * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
1152  * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1153  * for debug flags.
1154  *
1155  * \param ctx the context to initialize
1156  * \param api the GL API type to create the context for
1157  * \param visual describes the visual attributes for this context or NULL to
1158  *               create a configless context
1159  * \param share_list points to context to share textures, display lists,
1160  *        etc with, or NULL
1161  * \param driverFunctions table of device driver functions for this context
1162  *        to use
1163  */
1164 GLboolean
1165 _mesa_initialize_context(struct gl_context *ctx,
1166                          gl_api api,
1167                          const struct gl_config *visual,
1168                          struct gl_context *share_list,
1169                          const struct dd_function_table *driverFunctions)
1170 {
1171    struct gl_shared_state *shared;
1172    int i;
1173
1174    assert(driverFunctions->NewTextureObject);
1175    assert(driverFunctions->FreeTextureImageBuffer);
1176
1177    ctx->API = api;
1178    ctx->DrawBuffer = NULL;
1179    ctx->ReadBuffer = NULL;
1180    ctx->WinSysDrawBuffer = NULL;
1181    ctx->WinSysReadBuffer = NULL;
1182
1183    if (visual) {
1184       ctx->Visual = *visual;
1185       ctx->HasConfig = GL_TRUE;
1186    }
1187    else {
1188       memset(&ctx->Visual, 0, sizeof ctx->Visual);
1189       ctx->HasConfig = GL_FALSE;
1190    }
1191
1192    _mesa_override_gl_version(ctx);
1193
1194    /* misc one-time initializations */
1195    one_time_init(ctx);
1196
1197    _mesa_init_shader_compiler_types();
1198
1199    /* Plug in driver functions and context pointer here.
1200     * This is important because when we call alloc_shared_state() below
1201     * we'll call ctx->Driver.NewTextureObject() to create the default
1202     * textures.
1203     */
1204    ctx->Driver = *driverFunctions;
1205
1206    if (share_list) {
1207       /* share state with another context */
1208       shared = share_list->Shared;
1209    }
1210    else {
1211       /* allocate new, unshared state */
1212       shared = _mesa_alloc_shared_state(ctx);
1213       if (!shared)
1214          return GL_FALSE;
1215    }
1216
1217    _mesa_reference_shared_state(ctx, &ctx->Shared, shared);
1218
1219    if (!init_attrib_groups( ctx ))
1220       goto fail;
1221
1222    /* KHR_no_error is likely to crash, overflow memory, etc if an application
1223     * has errors so don't enable it for setuid processes.
1224     */
1225    if (env_var_as_boolean("MESA_NO_ERROR", false)) {
1226 #if !defined(_WIN32)
1227       if (geteuid() == getuid())
1228 #endif
1229          ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR;
1230    }
1231
1232    /* setup the API dispatch tables with all nop functions */
1233    ctx->OutsideBeginEnd = _mesa_alloc_dispatch_table();
1234    if (!ctx->OutsideBeginEnd)
1235       goto fail;
1236    ctx->Exec = ctx->OutsideBeginEnd;
1237    ctx->CurrentClientDispatch = ctx->CurrentServerDispatch = ctx->OutsideBeginEnd;
1238
1239    ctx->FragmentProgram._MaintainTexEnvProgram
1240       = (getenv("MESA_TEX_PROG") != NULL);
1241
1242    ctx->VertexProgram._MaintainTnlProgram
1243       = (getenv("MESA_TNL_PROG") != NULL);
1244    if (ctx->VertexProgram._MaintainTnlProgram) {
1245       /* this is required... */
1246       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1247    }
1248
1249    /* Mesa core handles all the formats that mesa core knows about.
1250     * Drivers will want to override this list with just the formats
1251     * they can handle, and confirm that appropriate fallbacks exist in
1252     * _mesa_choose_tex_format().
1253     */
1254    memset(&ctx->TextureFormatSupported, GL_TRUE,
1255           sizeof(ctx->TextureFormatSupported));
1256
1257    switch (ctx->API) {
1258    case API_OPENGL_COMPAT:
1259       ctx->BeginEnd = create_beginend_table(ctx);
1260       ctx->Save = _mesa_alloc_dispatch_table();
1261       if (!ctx->BeginEnd || !ctx->Save)
1262          goto fail;
1263
1264       /* fall-through */
1265    case API_OPENGL_CORE:
1266       break;
1267    case API_OPENGLES:
1268       /**
1269        * GL_OES_texture_cube_map says
1270        * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
1271        */
1272       for (i = 0; i < ARRAY_SIZE(ctx->Texture.FixedFuncUnit); i++) {
1273          struct gl_fixedfunc_texture_unit *texUnit =
1274             &ctx->Texture.FixedFuncUnit[i];
1275
1276          texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
1277          texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
1278          texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
1279          texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1280          texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1281          texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1282       }
1283       break;
1284    case API_OPENGLES2:
1285       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1286       ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
1287       break;
1288    }
1289
1290    ctx->FirstTimeCurrent = GL_TRUE;
1291
1292    return GL_TRUE;
1293
1294 fail:
1295    _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1296    free(ctx->BeginEnd);
1297    free(ctx->OutsideBeginEnd);
1298    free(ctx->Save);
1299    return GL_FALSE;
1300 }
1301
1302
1303 /**
1304  * Free the data associated with the given context.
1305  *
1306  * But doesn't free the struct gl_context struct itself.
1307  *
1308  * \sa _mesa_initialize_context() and init_attrib_groups().
1309  */
1310 void
1311 _mesa_free_context_data(struct gl_context *ctx, bool destroy_compiler_types)
1312 {
1313    if (!_mesa_get_current_context()){
1314       /* No current context, but we may need one in order to delete
1315        * texture objs, etc.  So temporarily bind the context now.
1316        */
1317       _mesa_make_current(ctx, NULL, NULL);
1318    }
1319
1320    /* unreference WinSysDraw/Read buffers */
1321    _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
1322    _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
1323    _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
1324    _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
1325
1326    _mesa_reference_program(ctx, &ctx->VertexProgram.Current, NULL);
1327    _mesa_reference_program(ctx, &ctx->VertexProgram._Current, NULL);
1328    _mesa_reference_program(ctx, &ctx->VertexProgram._TnlProgram, NULL);
1329
1330    _mesa_reference_program(ctx, &ctx->TessCtrlProgram._Current, NULL);
1331    _mesa_reference_program(ctx, &ctx->TessEvalProgram._Current, NULL);
1332    _mesa_reference_program(ctx, &ctx->GeometryProgram._Current, NULL);
1333
1334    _mesa_reference_program(ctx, &ctx->FragmentProgram.Current, NULL);
1335    _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, NULL);
1336    _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
1337
1338    _mesa_reference_program(ctx, &ctx->ComputeProgram._Current, NULL);
1339
1340    _mesa_reference_vao(ctx, &ctx->Array.VAO, NULL);
1341    _mesa_reference_vao(ctx, &ctx->Array.DefaultVAO, NULL);
1342    _mesa_reference_vao(ctx, &ctx->Array._EmptyVAO, NULL);
1343    _mesa_reference_vao(ctx, &ctx->Array._DrawVAO, NULL);
1344
1345    _mesa_free_attrib_data(ctx);
1346    _mesa_free_buffer_objects(ctx);
1347    _mesa_free_eval_data( ctx );
1348    _mesa_free_texture_data( ctx );
1349    _mesa_free_image_textures(ctx);
1350    _mesa_free_matrix_data( ctx );
1351    _mesa_free_pipeline_data(ctx);
1352    _mesa_free_program_data(ctx);
1353    _mesa_free_shader_state(ctx);
1354    _mesa_free_queryobj_data(ctx);
1355    _mesa_free_sync_data(ctx);
1356    _mesa_free_varray_data(ctx);
1357    _mesa_free_transform_feedback(ctx);
1358    _mesa_free_performance_monitors(ctx);
1359    _mesa_free_performance_queries(ctx);
1360    _mesa_free_resident_handles(ctx);
1361
1362    _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
1363    _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
1364    _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
1365    _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
1366
1367    /* free dispatch tables */
1368    free(ctx->BeginEnd);
1369    free(ctx->OutsideBeginEnd);
1370    free(ctx->Save);
1371    free(ctx->ContextLost);
1372    free(ctx->MarshalExec);
1373
1374    /* Shared context state (display lists, textures, etc) */
1375    _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1376
1377    /* needs to be after freeing shared state */
1378    _mesa_free_display_list_data(ctx);
1379
1380    _mesa_free_errors_data(ctx);
1381
1382    free((void *)ctx->Extensions.String);
1383
1384    free(ctx->VersionString);
1385
1386    if (destroy_compiler_types)
1387       _mesa_destroy_shader_compiler_types();
1388
1389    /* unbind the context if it's currently bound */
1390    if (ctx == _mesa_get_current_context()) {
1391       _mesa_make_current(NULL, NULL, NULL);
1392    }
1393 }
1394
1395
1396 /**
1397  * Destroy a struct gl_context structure.
1398  *
1399  * \param ctx GL context.
1400  *
1401  * Calls _mesa_free_context_data() and frees the gl_context object itself.
1402  */
1403 void
1404 _mesa_destroy_context( struct gl_context *ctx )
1405 {
1406    if (ctx) {
1407       _mesa_free_context_data(ctx, true);
1408       free( (void *) ctx );
1409    }
1410 }
1411
1412
1413 /**
1414  * Copy attribute groups from one context to another.
1415  *
1416  * \param src source context
1417  * \param dst destination context
1418  * \param mask bitwise OR of GL_*_BIT flags
1419  *
1420  * According to the bits specified in \p mask, copies the corresponding
1421  * attributes from \p src into \p dst.  For many of the attributes a simple \c
1422  * memcpy is not enough due to the existence of internal pointers in their data
1423  * structures.
1424  */
1425 void
1426 _mesa_copy_context( const struct gl_context *src, struct gl_context *dst,
1427                     GLuint mask )
1428 {
1429    if (mask & GL_ACCUM_BUFFER_BIT) {
1430       /* OK to memcpy */
1431       dst->Accum = src->Accum;
1432    }
1433    if (mask & GL_COLOR_BUFFER_BIT) {
1434       /* OK to memcpy */
1435       dst->Color = src->Color;
1436    }
1437    if (mask & GL_CURRENT_BIT) {
1438       /* OK to memcpy */
1439       dst->Current = src->Current;
1440    }
1441    if (mask & GL_DEPTH_BUFFER_BIT) {
1442       /* OK to memcpy */
1443       dst->Depth = src->Depth;
1444    }
1445    if (mask & GL_ENABLE_BIT) {
1446       /* no op */
1447    }
1448    if (mask & GL_EVAL_BIT) {
1449       /* OK to memcpy */
1450       dst->Eval = src->Eval;
1451    }
1452    if (mask & GL_FOG_BIT) {
1453       /* OK to memcpy */
1454       dst->Fog = src->Fog;
1455    }
1456    if (mask & GL_HINT_BIT) {
1457       /* OK to memcpy */
1458       dst->Hint = src->Hint;
1459    }
1460    if (mask & GL_LIGHTING_BIT) {
1461       /* OK to memcpy */
1462       dst->Light = src->Light;
1463    }
1464    if (mask & GL_LINE_BIT) {
1465       /* OK to memcpy */
1466       dst->Line = src->Line;
1467    }
1468    if (mask & GL_LIST_BIT) {
1469       /* OK to memcpy */
1470       dst->List = src->List;
1471    }
1472    if (mask & GL_PIXEL_MODE_BIT) {
1473       /* OK to memcpy */
1474       dst->Pixel = src->Pixel;
1475    }
1476    if (mask & GL_POINT_BIT) {
1477       /* OK to memcpy */
1478       dst->Point = src->Point;
1479    }
1480    if (mask & GL_POLYGON_BIT) {
1481       /* OK to memcpy */
1482       dst->Polygon = src->Polygon;
1483    }
1484    if (mask & GL_POLYGON_STIPPLE_BIT) {
1485       /* Use loop instead of memcpy due to problem with Portland Group's
1486        * C compiler.  Reported by John Stone.
1487        */
1488       GLuint i;
1489       for (i = 0; i < 32; i++) {
1490          dst->PolygonStipple[i] = src->PolygonStipple[i];
1491       }
1492    }
1493    if (mask & GL_SCISSOR_BIT) {
1494       /* OK to memcpy */
1495       dst->Scissor = src->Scissor;
1496    }
1497    if (mask & GL_STENCIL_BUFFER_BIT) {
1498       /* OK to memcpy */
1499       dst->Stencil = src->Stencil;
1500    }
1501    if (mask & GL_TEXTURE_BIT) {
1502       /* Cannot memcpy because of pointers */
1503       _mesa_copy_texture_state(src, dst);
1504    }
1505    if (mask & GL_TRANSFORM_BIT) {
1506       /* OK to memcpy */
1507       dst->Transform = src->Transform;
1508    }
1509    if (mask & GL_VIEWPORT_BIT) {
1510       unsigned i;
1511       for (i = 0; i < src->Const.MaxViewports; i++) {
1512          /* OK to memcpy */
1513          dst->ViewportArray[i] = src->ViewportArray[i];
1514       }
1515    }
1516
1517    /* XXX FIXME:  Call callbacks?
1518     */
1519    dst->NewState = _NEW_ALL;
1520    dst->NewDriverState = ~0;
1521 }
1522
1523
1524 /**
1525  * Check if the given context can render into the given framebuffer
1526  * by checking visual attributes.
1527  *
1528  * \return GL_TRUE if compatible, GL_FALSE otherwise.
1529  */
1530 static GLboolean
1531 check_compatible(const struct gl_context *ctx,
1532                  const struct gl_framebuffer *buffer)
1533 {
1534    const struct gl_config *ctxvis = &ctx->Visual;
1535    const struct gl_config *bufvis = &buffer->Visual;
1536
1537    if (buffer == _mesa_get_incomplete_framebuffer())
1538       return GL_TRUE;
1539
1540 #define check_component(foo)           \
1541    if (ctxvis->foo && bufvis->foo &&   \
1542        ctxvis->foo != bufvis->foo)     \
1543       return GL_FALSE
1544
1545    check_component(redMask);
1546    check_component(greenMask);
1547    check_component(blueMask);
1548    check_component(depthBits);
1549    check_component(stencilBits);
1550
1551 #undef check_component
1552
1553    return GL_TRUE;
1554 }
1555
1556
1557 /**
1558  * Check if the viewport/scissor size has not yet been initialized.
1559  * Initialize the size if the given width and height are non-zero.
1560  */
1561 static void
1562 check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
1563 {
1564    if (!ctx->ViewportInitialized && width > 0 && height > 0) {
1565       unsigned i;
1566
1567       /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
1568        * potential infinite recursion.
1569        */
1570       ctx->ViewportInitialized = GL_TRUE;
1571
1572       /* Note: ctx->Const.MaxViewports may not have been set by the driver
1573        * yet, so just initialize all of them.
1574        */
1575       for (i = 0; i < MAX_VIEWPORTS; i++) {
1576          _mesa_set_viewport(ctx, i, 0, 0, width, height);
1577          _mesa_set_scissor(ctx, i, 0, 0, width, height);
1578       }
1579    }
1580 }
1581
1582
1583 static void
1584 handle_first_current(struct gl_context *ctx)
1585 {
1586    if (ctx->Version == 0 || !ctx->DrawBuffer) {
1587       /* probably in the process of tearing down the context */
1588       return;
1589    }
1590
1591    check_context_limits(ctx);
1592
1593    _mesa_update_vertex_processing_mode(ctx);
1594
1595    /* According to GL_MESA_configless_context the default value of
1596     * glDrawBuffers depends on the config of the first surface it is bound to.
1597     * For GLES it is always GL_BACK which has a magic interpretation.
1598     */
1599    if (!ctx->HasConfig && _mesa_is_desktop_gl(ctx)) {
1600       if (ctx->DrawBuffer != _mesa_get_incomplete_framebuffer()) {
1601          GLenum16 buffer;
1602
1603          if (ctx->DrawBuffer->Visual.doubleBufferMode)
1604             buffer = GL_BACK;
1605          else
1606             buffer = GL_FRONT;
1607
1608          _mesa_drawbuffers(ctx, ctx->DrawBuffer, 1, &buffer,
1609                            NULL /* destMask */);
1610       }
1611
1612       if (ctx->ReadBuffer != _mesa_get_incomplete_framebuffer()) {
1613          gl_buffer_index bufferIndex;
1614          GLenum buffer;
1615
1616          if (ctx->ReadBuffer->Visual.doubleBufferMode) {
1617             buffer = GL_BACK;
1618             bufferIndex = BUFFER_BACK_LEFT;
1619          }
1620          else {
1621             buffer = GL_FRONT;
1622             bufferIndex = BUFFER_FRONT_LEFT;
1623          }
1624
1625          _mesa_readbuffer(ctx, ctx->ReadBuffer, buffer, bufferIndex);
1626       }
1627    }
1628
1629    /* Determine if generic vertex attribute 0 aliases the conventional
1630     * glVertex position.
1631     */
1632    {
1633       const bool is_forward_compatible_context =
1634          ctx->Const.ContextFlags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT;
1635
1636       /* In OpenGL 3.1 attribute 0 becomes non-magic, just like in OpenGL ES
1637        * 2.0.  Note that we cannot just check for API_OPENGL_COMPAT here because
1638        * that will erroneously allow this usage in a 3.0 forward-compatible
1639        * context too.
1640        */
1641       ctx->_AttribZeroAliasesVertex = (ctx->API == API_OPENGLES
1642                                        || (ctx->API == API_OPENGL_COMPAT
1643                                            && !is_forward_compatible_context));
1644    }
1645
1646    /* We can use this to help debug user's problems.  Tell them to set
1647     * the MESA_INFO env variable before running their app.  Then the
1648     * first time each context is made current we'll print some useful
1649     * information.
1650     */
1651    if (getenv("MESA_INFO")) {
1652       _mesa_print_info(ctx);
1653    }
1654 }
1655
1656 /**
1657  * Bind the given context to the given drawBuffer and readBuffer and
1658  * make it the current context for the calling thread.
1659  * We'll render into the drawBuffer and read pixels from the
1660  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1661  *
1662  * We check that the context's and framebuffer's visuals are compatible
1663  * and return immediately if they're not.
1664  *
1665  * \param newCtx  the new GL context. If NULL then there will be no current GL
1666  *                context.
1667  * \param drawBuffer  the drawing framebuffer
1668  * \param readBuffer  the reading framebuffer
1669  */
1670 GLboolean
1671 _mesa_make_current( struct gl_context *newCtx,
1672                     struct gl_framebuffer *drawBuffer,
1673                     struct gl_framebuffer *readBuffer )
1674 {
1675    GET_CURRENT_CONTEXT(curCtx);
1676
1677    if (MESA_VERBOSE & VERBOSE_API)
1678       _mesa_debug(newCtx, "_mesa_make_current()\n");
1679
1680    /* Check that the context's and framebuffer's visuals are compatible.
1681     */
1682    if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1683       if (!check_compatible(newCtx, drawBuffer)) {
1684          _mesa_warning(newCtx,
1685               "MakeCurrent: incompatible visuals for context and drawbuffer");
1686          return GL_FALSE;
1687       }
1688    }
1689    if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1690       if (!check_compatible(newCtx, readBuffer)) {
1691          _mesa_warning(newCtx,
1692               "MakeCurrent: incompatible visuals for context and readbuffer");
1693          return GL_FALSE;
1694       }
1695    }
1696
1697    if (curCtx &&
1698        (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) &&
1699        /* make sure this context is valid for flushing */
1700        curCtx != newCtx &&
1701        curCtx->Const.ContextReleaseBehavior ==
1702        GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH) {
1703       _mesa_flush(curCtx);
1704    }
1705
1706    /* Call this periodically to detect when the user has begun using
1707     * GL rendering from multiple threads.
1708     */
1709    _glapi_check_multithread();
1710
1711    if (!newCtx) {
1712       _glapi_set_dispatch(NULL);  /* none current */
1713       /* We need old ctx to correctly release Draw/ReadBuffer
1714        * and avoid a surface leak in st_renderbuffer_delete.
1715        * Therefore, first drop buffers then set new ctx to NULL.
1716        */
1717       if (curCtx) {
1718          _mesa_reference_framebuffer(&curCtx->WinSysDrawBuffer, NULL);
1719          _mesa_reference_framebuffer(&curCtx->WinSysReadBuffer, NULL);
1720       }
1721       _glapi_set_context(NULL);
1722       assert(_mesa_get_current_context() == NULL);
1723    }
1724    else {
1725       _glapi_set_context((void *) newCtx);
1726       assert(_mesa_get_current_context() == newCtx);
1727       _glapi_set_dispatch(newCtx->CurrentClientDispatch);
1728
1729       if (drawBuffer && readBuffer) {
1730          assert(_mesa_is_winsys_fbo(drawBuffer));
1731          assert(_mesa_is_winsys_fbo(readBuffer));
1732          _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1733          _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1734
1735          /*
1736           * Only set the context's Draw/ReadBuffer fields if they're NULL
1737           * or not bound to a user-created FBO.
1738           */
1739          if (!newCtx->DrawBuffer || _mesa_is_winsys_fbo(newCtx->DrawBuffer)) {
1740             _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1741             /* Update the FBO's list of drawbuffers/renderbuffers.
1742              * For winsys FBOs this comes from the GL state (which may have
1743              * changed since the last time this FBO was bound).
1744              */
1745             _mesa_update_draw_buffers(newCtx);
1746          }
1747          if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) {
1748             _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1749             /* In _mesa_initialize_window_framebuffer, for single-buffered
1750              * visuals, the ColorReadBuffer is set to be GL_FRONT, even with
1751              * GLES contexts. When calling read_buffer, we verify we are reading
1752              * from GL_BACK in is_legal_es3_readbuffer_enum.  But the default is
1753              * incorrect, and certain dEQP tests check this.  So fix it here.
1754              */
1755             if (_mesa_is_gles(newCtx) &&
1756                !newCtx->ReadBuffer->Visual.doubleBufferMode)
1757                if (newCtx->ReadBuffer->ColorReadBuffer == GL_FRONT)
1758                   newCtx->ReadBuffer->ColorReadBuffer = GL_BACK;
1759          }
1760
1761          /* XXX only set this flag if we're really changing the draw/read
1762           * framebuffer bindings.
1763           */
1764          newCtx->NewState |= _NEW_BUFFERS;
1765
1766          check_init_viewport(newCtx, drawBuffer->Width, drawBuffer->Height);
1767       }
1768
1769       if (newCtx->FirstTimeCurrent) {
1770          handle_first_current(newCtx);
1771          newCtx->FirstTimeCurrent = GL_FALSE;
1772       }
1773    }
1774
1775    return GL_TRUE;
1776 }
1777
1778
1779 /**
1780  * Make context 'ctx' share the display lists, textures and programs
1781  * that are associated with 'ctxToShare'.
1782  * Any display lists, textures or programs associated with 'ctx' will
1783  * be deleted if nobody else is sharing them.
1784  */
1785 GLboolean
1786 _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
1787 {
1788    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1789       struct gl_shared_state *oldShared = NULL;
1790
1791       /* save ref to old state to prevent it from being deleted immediately */
1792       _mesa_reference_shared_state(ctx, &oldShared, ctx->Shared);
1793
1794       /* update ctx's Shared pointer */
1795       _mesa_reference_shared_state(ctx, &ctx->Shared, ctxToShare->Shared);
1796
1797       update_default_objects(ctx);
1798
1799       /* release the old shared state */
1800       _mesa_reference_shared_state(ctx, &oldShared, NULL);
1801
1802       return GL_TRUE;
1803    }
1804    else {
1805       return GL_FALSE;
1806    }
1807 }
1808
1809
1810
1811 /**
1812  * \return pointer to the current GL context for this thread.
1813  *
1814  * Calls _glapi_get_context(). This isn't the fastest way to get the current
1815  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
1816  * context.h.
1817  */
1818 struct gl_context *
1819 _mesa_get_current_context( void )
1820 {
1821    return (struct gl_context *) _glapi_get_context();
1822 }
1823
1824
1825 /**
1826  * Get context's current API dispatch table.
1827  *
1828  * It'll either be the immediate-mode execute dispatcher, the display list
1829  * compile dispatcher, or the thread marshalling dispatcher.
1830  *
1831  * \param ctx GL context.
1832  *
1833  * \return pointer to dispatch_table.
1834  *
1835  * Simply returns __struct gl_contextRec::CurrentClientDispatch.
1836  */
1837 struct _glapi_table *
1838 _mesa_get_dispatch(struct gl_context *ctx)
1839 {
1840    return ctx->CurrentClientDispatch;
1841 }
1842
1843 /*@}*/
1844
1845
1846 /**********************************************************************/
1847 /** \name Miscellaneous functions                                     */
1848 /**********************************************************************/
1849 /*@{*/
1850 /**
1851  * Flush commands.
1852  */
1853 void
1854 _mesa_flush(struct gl_context *ctx)
1855 {
1856    FLUSH_VERTICES( ctx, 0 );
1857    FLUSH_CURRENT( ctx, 0 );
1858    if (ctx->Driver.Flush) {
1859       ctx->Driver.Flush(ctx);
1860    }
1861 }
1862
1863
1864
1865 /**
1866  * Flush commands and wait for completion.
1867  *
1868  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1869  * dd_function_table::Finish driver callback, if not NULL.
1870  */
1871 void GLAPIENTRY
1872 _mesa_Finish(void)
1873 {
1874    GET_CURRENT_CONTEXT(ctx);
1875    ASSERT_OUTSIDE_BEGIN_END(ctx);
1876
1877    FLUSH_VERTICES(ctx, 0);
1878    FLUSH_CURRENT(ctx, 0);
1879
1880    if (ctx->Driver.Finish) {
1881       ctx->Driver.Finish(ctx);
1882    }
1883 }
1884
1885
1886 /**
1887  * Execute glFlush().
1888  *
1889  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1890  * dd_function_table::Flush driver callback, if not NULL.
1891  */
1892 void GLAPIENTRY
1893 _mesa_Flush(void)
1894 {
1895    GET_CURRENT_CONTEXT(ctx);
1896    ASSERT_OUTSIDE_BEGIN_END(ctx);
1897    _mesa_flush(ctx);
1898 }
1899
1900
1901 /*@}*/