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