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 )
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    _mesa_destroy_shader_compiler_types();
1389
1390    /* unbind the context if it's currently bound */
1391    if (ctx == _mesa_get_current_context()) {
1392       _mesa_make_current(NULL, NULL, NULL);
1393    }
1394 }
1395
1396
1397 /**
1398  * Destroy a struct gl_context structure.
1399  *
1400  * \param ctx GL context.
1401  *
1402  * Calls _mesa_free_context_data() and frees the gl_context object itself.
1403  */
1404 void
1405 _mesa_destroy_context( struct gl_context *ctx )
1406 {
1407    if (ctx) {
1408       _mesa_free_context_data(ctx);
1409       free( (void *) ctx );
1410    }
1411 }
1412
1413
1414 /**
1415  * Copy attribute groups from one context to another.
1416  *
1417  * \param src source context
1418  * \param dst destination context
1419  * \param mask bitwise OR of GL_*_BIT flags
1420  *
1421  * According to the bits specified in \p mask, copies the corresponding
1422  * attributes from \p src into \p dst.  For many of the attributes a simple \c
1423  * memcpy is not enough due to the existence of internal pointers in their data
1424  * structures.
1425  */
1426 void
1427 _mesa_copy_context( const struct gl_context *src, struct gl_context *dst,
1428                     GLuint mask )
1429 {
1430    if (mask & GL_ACCUM_BUFFER_BIT) {
1431       /* OK to memcpy */
1432       dst->Accum = src->Accum;
1433    }
1434    if (mask & GL_COLOR_BUFFER_BIT) {
1435       /* OK to memcpy */
1436       dst->Color = src->Color;
1437    }
1438    if (mask & GL_CURRENT_BIT) {
1439       /* OK to memcpy */
1440       dst->Current = src->Current;
1441    }
1442    if (mask & GL_DEPTH_BUFFER_BIT) {
1443       /* OK to memcpy */
1444       dst->Depth = src->Depth;
1445    }
1446    if (mask & GL_ENABLE_BIT) {
1447       /* no op */
1448    }
1449    if (mask & GL_EVAL_BIT) {
1450       /* OK to memcpy */
1451       dst->Eval = src->Eval;
1452    }
1453    if (mask & GL_FOG_BIT) {
1454       /* OK to memcpy */
1455       dst->Fog = src->Fog;
1456    }
1457    if (mask & GL_HINT_BIT) {
1458       /* OK to memcpy */
1459       dst->Hint = src->Hint;
1460    }
1461    if (mask & GL_LIGHTING_BIT) {
1462       /* OK to memcpy */
1463       dst->Light = src->Light;
1464    }
1465    if (mask & GL_LINE_BIT) {
1466       /* OK to memcpy */
1467       dst->Line = src->Line;
1468    }
1469    if (mask & GL_LIST_BIT) {
1470       /* OK to memcpy */
1471       dst->List = src->List;
1472    }
1473    if (mask & GL_PIXEL_MODE_BIT) {
1474       /* OK to memcpy */
1475       dst->Pixel = src->Pixel;
1476    }
1477    if (mask & GL_POINT_BIT) {
1478       /* OK to memcpy */
1479       dst->Point = src->Point;
1480    }
1481    if (mask & GL_POLYGON_BIT) {
1482       /* OK to memcpy */
1483       dst->Polygon = src->Polygon;
1484    }
1485    if (mask & GL_POLYGON_STIPPLE_BIT) {
1486       /* Use loop instead of memcpy due to problem with Portland Group's
1487        * C compiler.  Reported by John Stone.
1488        */
1489       GLuint i;
1490       for (i = 0; i < 32; i++) {
1491          dst->PolygonStipple[i] = src->PolygonStipple[i];
1492       }
1493    }
1494    if (mask & GL_SCISSOR_BIT) {
1495       /* OK to memcpy */
1496       dst->Scissor = src->Scissor;
1497    }
1498    if (mask & GL_STENCIL_BUFFER_BIT) {
1499       /* OK to memcpy */
1500       dst->Stencil = src->Stencil;
1501    }
1502    if (mask & GL_TEXTURE_BIT) {
1503       /* Cannot memcpy because of pointers */
1504       _mesa_copy_texture_state(src, dst);
1505    }
1506    if (mask & GL_TRANSFORM_BIT) {
1507       /* OK to memcpy */
1508       dst->Transform = src->Transform;
1509    }
1510    if (mask & GL_VIEWPORT_BIT) {
1511       unsigned i;
1512       for (i = 0; i < src->Const.MaxViewports; i++) {
1513          /* OK to memcpy */
1514          dst->ViewportArray[i] = src->ViewportArray[i];
1515       }
1516    }
1517
1518    /* XXX FIXME:  Call callbacks?
1519     */
1520    dst->NewState = _NEW_ALL;
1521    dst->NewDriverState = ~0;
1522 }
1523
1524
1525 /**
1526  * Check if the given context can render into the given framebuffer
1527  * by checking visual attributes.
1528  *
1529  * \return GL_TRUE if compatible, GL_FALSE otherwise.
1530  */
1531 static GLboolean
1532 check_compatible(const struct gl_context *ctx,
1533                  const struct gl_framebuffer *buffer)
1534 {
1535    const struct gl_config *ctxvis = &ctx->Visual;
1536    const struct gl_config *bufvis = &buffer->Visual;
1537
1538    if (buffer == _mesa_get_incomplete_framebuffer())
1539       return GL_TRUE;
1540
1541 #define check_component(foo)           \
1542    if (ctxvis->foo && bufvis->foo &&   \
1543        ctxvis->foo != bufvis->foo)     \
1544       return GL_FALSE
1545
1546    check_component(redMask);
1547    check_component(greenMask);
1548    check_component(blueMask);
1549    check_component(depthBits);
1550    check_component(stencilBits);
1551
1552 #undef check_component
1553
1554    return GL_TRUE;
1555 }
1556
1557
1558 /**
1559  * Check if the viewport/scissor size has not yet been initialized.
1560  * Initialize the size if the given width and height are non-zero.
1561  */
1562 static void
1563 check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
1564 {
1565    if (!ctx->ViewportInitialized && width > 0 && height > 0) {
1566       unsigned i;
1567
1568       /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
1569        * potential infinite recursion.
1570        */
1571       ctx->ViewportInitialized = GL_TRUE;
1572
1573       /* Note: ctx->Const.MaxViewports may not have been set by the driver
1574        * yet, so just initialize all of them.
1575        */
1576       for (i = 0; i < MAX_VIEWPORTS; i++) {
1577          _mesa_set_viewport(ctx, i, 0, 0, width, height);
1578          _mesa_set_scissor(ctx, i, 0, 0, width, height);
1579       }
1580    }
1581 }
1582
1583
1584 static void
1585 handle_first_current(struct gl_context *ctx)
1586 {
1587    if (ctx->Version == 0 || !ctx->DrawBuffer) {
1588       /* probably in the process of tearing down the context */
1589       return;
1590    }
1591
1592    check_context_limits(ctx);
1593
1594    _mesa_update_vertex_processing_mode(ctx);
1595
1596    /* According to GL_MESA_configless_context the default value of
1597     * glDrawBuffers depends on the config of the first surface it is bound to.
1598     * For GLES it is always GL_BACK which has a magic interpretation.
1599     */
1600    if (!ctx->HasConfig && _mesa_is_desktop_gl(ctx)) {
1601       if (ctx->DrawBuffer != _mesa_get_incomplete_framebuffer()) {
1602          GLenum16 buffer;
1603
1604          if (ctx->DrawBuffer->Visual.doubleBufferMode)
1605             buffer = GL_BACK;
1606          else
1607             buffer = GL_FRONT;
1608
1609          _mesa_drawbuffers(ctx, ctx->DrawBuffer, 1, &buffer,
1610                            NULL /* destMask */);
1611       }
1612
1613       if (ctx->ReadBuffer != _mesa_get_incomplete_framebuffer()) {
1614          gl_buffer_index bufferIndex;
1615          GLenum buffer;
1616
1617          if (ctx->ReadBuffer->Visual.doubleBufferMode) {
1618             buffer = GL_BACK;
1619             bufferIndex = BUFFER_BACK_LEFT;
1620          }
1621          else {
1622             buffer = GL_FRONT;
1623             bufferIndex = BUFFER_FRONT_LEFT;
1624          }
1625
1626          _mesa_readbuffer(ctx, ctx->ReadBuffer, buffer, bufferIndex);
1627       }
1628    }
1629
1630    /* Determine if generic vertex attribute 0 aliases the conventional
1631     * glVertex position.
1632     */
1633    {
1634       const bool is_forward_compatible_context =
1635          ctx->Const.ContextFlags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT;
1636
1637       /* In OpenGL 3.1 attribute 0 becomes non-magic, just like in OpenGL ES
1638        * 2.0.  Note that we cannot just check for API_OPENGL_COMPAT here because
1639        * that will erroneously allow this usage in a 3.0 forward-compatible
1640        * context too.
1641        */
1642       ctx->_AttribZeroAliasesVertex = (ctx->API == API_OPENGLES
1643                                        || (ctx->API == API_OPENGL_COMPAT
1644                                            && !is_forward_compatible_context));
1645    }
1646
1647    /* We can use this to help debug user's problems.  Tell them to set
1648     * the MESA_INFO env variable before running their app.  Then the
1649     * first time each context is made current we'll print some useful
1650     * information.
1651     */
1652    if (getenv("MESA_INFO")) {
1653       _mesa_print_info(ctx);
1654    }
1655 }
1656
1657 /**
1658  * Bind the given context to the given drawBuffer and readBuffer and
1659  * make it the current context for the calling thread.
1660  * We'll render into the drawBuffer and read pixels from the
1661  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1662  *
1663  * We check that the context's and framebuffer's visuals are compatible
1664  * and return immediately if they're not.
1665  *
1666  * \param newCtx  the new GL context. If NULL then there will be no current GL
1667  *                context.
1668  * \param drawBuffer  the drawing framebuffer
1669  * \param readBuffer  the reading framebuffer
1670  */
1671 GLboolean
1672 _mesa_make_current( struct gl_context *newCtx,
1673                     struct gl_framebuffer *drawBuffer,
1674                     struct gl_framebuffer *readBuffer )
1675 {
1676    GET_CURRENT_CONTEXT(curCtx);
1677
1678    if (MESA_VERBOSE & VERBOSE_API)
1679       _mesa_debug(newCtx, "_mesa_make_current()\n");
1680
1681    /* Check that the context's and framebuffer's visuals are compatible.
1682     */
1683    if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1684       if (!check_compatible(newCtx, drawBuffer)) {
1685          _mesa_warning(newCtx,
1686               "MakeCurrent: incompatible visuals for context and drawbuffer");
1687          return GL_FALSE;
1688       }
1689    }
1690    if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1691       if (!check_compatible(newCtx, readBuffer)) {
1692          _mesa_warning(newCtx,
1693               "MakeCurrent: incompatible visuals for context and readbuffer");
1694          return GL_FALSE;
1695       }
1696    }
1697
1698    if (curCtx &&
1699        (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) &&
1700        /* make sure this context is valid for flushing */
1701        curCtx != newCtx &&
1702        curCtx->Const.ContextReleaseBehavior ==
1703        GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH) {
1704       _mesa_flush(curCtx);
1705    }
1706
1707    /* Call this periodically to detect when the user has begun using
1708     * GL rendering from multiple threads.
1709     */
1710    _glapi_check_multithread();
1711
1712    if (!newCtx) {
1713       _glapi_set_dispatch(NULL);  /* none current */
1714       /* We need old ctx to correctly release Draw/ReadBuffer
1715        * and avoid a surface leak in st_renderbuffer_delete.
1716        * Therefore, first drop buffers then set new ctx to NULL.
1717        */
1718       if (curCtx) {
1719          _mesa_reference_framebuffer(&curCtx->WinSysDrawBuffer, NULL);
1720          _mesa_reference_framebuffer(&curCtx->WinSysReadBuffer, NULL);
1721       }
1722       _glapi_set_context(NULL);
1723       assert(_mesa_get_current_context() == NULL);
1724    }
1725    else {
1726       _glapi_set_context((void *) newCtx);
1727       assert(_mesa_get_current_context() == newCtx);
1728       _glapi_set_dispatch(newCtx->CurrentClientDispatch);
1729
1730       if (drawBuffer && readBuffer) {
1731          assert(_mesa_is_winsys_fbo(drawBuffer));
1732          assert(_mesa_is_winsys_fbo(readBuffer));
1733          _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1734          _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1735
1736          /*
1737           * Only set the context's Draw/ReadBuffer fields if they're NULL
1738           * or not bound to a user-created FBO.
1739           */
1740          if (!newCtx->DrawBuffer || _mesa_is_winsys_fbo(newCtx->DrawBuffer)) {
1741             _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1742             /* Update the FBO's list of drawbuffers/renderbuffers.
1743              * For winsys FBOs this comes from the GL state (which may have
1744              * changed since the last time this FBO was bound).
1745              */
1746             _mesa_update_draw_buffers(newCtx);
1747          }
1748          if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) {
1749             _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1750             /* In _mesa_initialize_window_framebuffer, for single-buffered
1751              * visuals, the ColorReadBuffer is set to be GL_FRONT, even with
1752              * GLES contexts. When calling read_buffer, we verify we are reading
1753              * from GL_BACK in is_legal_es3_readbuffer_enum.  But the default is
1754              * incorrect, and certain dEQP tests check this.  So fix it here.
1755              */
1756             if (_mesa_is_gles(newCtx) &&
1757                !newCtx->ReadBuffer->Visual.doubleBufferMode)
1758                if (newCtx->ReadBuffer->ColorReadBuffer == GL_FRONT)
1759                   newCtx->ReadBuffer->ColorReadBuffer = GL_BACK;
1760          }
1761
1762          /* XXX only set this flag if we're really changing the draw/read
1763           * framebuffer bindings.
1764           */
1765          newCtx->NewState |= _NEW_BUFFERS;
1766
1767          check_init_viewport(newCtx, drawBuffer->Width, drawBuffer->Height);
1768       }
1769
1770       if (newCtx->FirstTimeCurrent) {
1771          handle_first_current(newCtx);
1772          newCtx->FirstTimeCurrent = GL_FALSE;
1773       }
1774    }
1775
1776    return GL_TRUE;
1777 }
1778
1779
1780 /**
1781  * Make context 'ctx' share the display lists, textures and programs
1782  * that are associated with 'ctxToShare'.
1783  * Any display lists, textures or programs associated with 'ctx' will
1784  * be deleted if nobody else is sharing them.
1785  */
1786 GLboolean
1787 _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
1788 {
1789    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1790       struct gl_shared_state *oldShared = NULL;
1791
1792       /* save ref to old state to prevent it from being deleted immediately */
1793       _mesa_reference_shared_state(ctx, &oldShared, ctx->Shared);
1794
1795       /* update ctx's Shared pointer */
1796       _mesa_reference_shared_state(ctx, &ctx->Shared, ctxToShare->Shared);
1797
1798       update_default_objects(ctx);
1799
1800       /* release the old shared state */
1801       _mesa_reference_shared_state(ctx, &oldShared, NULL);
1802
1803       return GL_TRUE;
1804    }
1805    else {
1806       return GL_FALSE;
1807    }
1808 }
1809
1810
1811
1812 /**
1813  * \return pointer to the current GL context for this thread.
1814  *
1815  * Calls _glapi_get_context(). This isn't the fastest way to get the current
1816  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
1817  * context.h.
1818  */
1819 struct gl_context *
1820 _mesa_get_current_context( void )
1821 {
1822    return (struct gl_context *) _glapi_get_context();
1823 }
1824
1825
1826 /**
1827  * Get context's current API dispatch table.
1828  *
1829  * It'll either be the immediate-mode execute dispatcher, the display list
1830  * compile dispatcher, or the thread marshalling dispatcher.
1831  *
1832  * \param ctx GL context.
1833  *
1834  * \return pointer to dispatch_table.
1835  *
1836  * Simply returns __struct gl_contextRec::CurrentClientDispatch.
1837  */
1838 struct _glapi_table *
1839 _mesa_get_dispatch(struct gl_context *ctx)
1840 {
1841    return ctx->CurrentClientDispatch;
1842 }
1843
1844 /*@}*/
1845
1846
1847 /**********************************************************************/
1848 /** \name Miscellaneous functions                                     */
1849 /**********************************************************************/
1850 /*@{*/
1851 /**
1852  * Flush commands.
1853  */
1854 void
1855 _mesa_flush(struct gl_context *ctx)
1856 {
1857    FLUSH_VERTICES( ctx, 0 );
1858    FLUSH_CURRENT( ctx, 0 );
1859    if (ctx->Driver.Flush) {
1860       ctx->Driver.Flush(ctx);
1861    }
1862 }
1863
1864
1865
1866 /**
1867  * Flush commands and wait for completion.
1868  *
1869  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1870  * dd_function_table::Finish driver callback, if not NULL.
1871  */
1872 void GLAPIENTRY
1873 _mesa_Finish(void)
1874 {
1875    GET_CURRENT_CONTEXT(ctx);
1876    ASSERT_OUTSIDE_BEGIN_END(ctx);
1877
1878    FLUSH_VERTICES(ctx, 0);
1879    FLUSH_CURRENT(ctx, 0);
1880
1881    if (ctx->Driver.Finish) {
1882       ctx->Driver.Finish(ctx);
1883    }
1884 }
1885
1886
1887 /**
1888  * Execute glFlush().
1889  *
1890  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1891  * dd_function_table::Flush driver callback, if not NULL.
1892  */
1893 void GLAPIENTRY
1894 _mesa_Flush(void)
1895 {
1896    GET_CURRENT_CONTEXT(ctx);
1897    ASSERT_OUTSIDE_BEGIN_END(ctx);
1898    _mesa_flush(ctx);
1899 }
1900
1901
1902 /*@}*/