src/mesa/main/context.c

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