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