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