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
 637 #ifdef DEBUG
 638    consts->GenerateTemporaryNames = true;
 639 #else
 640    consts->GenerateTemporaryNames = false;
 641 #endif
 642
 643    /* GL_ARB_framebuffer_object */
 644    consts->MaxSamples = 0;
 645
 646    /* GLSL default if NativeIntegers == FALSE */
 647    consts->UniformBooleanTrue = FLOAT_AS_UNION(1.0f).u;
 648
 649    /* GL_ARB_sync */
 650    consts->MaxServerWaitTimeout = 0x7fffffff7fffffffULL;
 651
 652    /* GL_EXT_provoking_vertex */
 653    consts->QuadsFollowProvokingVertexConvention = GL_TRUE;
 654
 655    /** GL_ARB_viewport_array */
 656    consts->LayerAndVPIndexProvokingVertex = GL_UNDEFINED_VERTEX;
 657
 658    /* GL_EXT_transform_feedback */
 659    consts->MaxTransformFeedbackBuffers = MAX_FEEDBACK_BUFFERS;
 660    consts->MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;
 661    consts->MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;
 662    consts->MaxVertexStreams = 1;
 663
 664    /* GL 3.2  */
 665    consts->ProfileMask = api == API_OPENGL_CORE
 666                           ? GL_CONTEXT_CORE_PROFILE_BIT
 667                           : GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
 668
 669    /* GL 4.4 */
 670    consts->MaxVertexAttribStride = 2048;
 671
 672    /** GL_EXT_gpu_shader4 */
 673    consts->MinProgramTexelOffset = -8;
 674    consts->MaxProgramTexelOffset = 7;
 675
 676    /* GL_ARB_texture_gather */
 677    consts->MinProgramTextureGatherOffset = -8;
 678    consts->MaxProgramTextureGatherOffset = 7;
 679
 680    /* GL_ARB_robustness */
 681    consts->ResetStrategy = GL_NO_RESET_NOTIFICATION_ARB;
 682
 683    /* GL_KHR_robustness */
 684    consts->RobustAccess = GL_FALSE;
 685
 686    /* ES 3.0 or ARB_ES3_compatibility */
 687    consts->MaxElementIndex = 0xffffffffu;
 688
 689    /* GL_ARB_texture_multisample */
 690    consts->MaxColorTextureSamples = 1;
 691    consts->MaxDepthTextureSamples = 1;
 692    consts->MaxIntegerSamples = 1;
 693
 694    /* GL_ARB_shader_atomic_counters */
 695    consts->MaxAtomicBufferBindings = MAX_COMBINED_ATOMIC_BUFFERS;
 696    consts->MaxAtomicBufferSize = MAX_ATOMIC_COUNTERS * ATOMIC_COUNTER_SIZE;
 697    consts->MaxCombinedAtomicBuffers = MAX_COMBINED_ATOMIC_BUFFERS;
 698    consts->MaxCombinedAtomicCounters = MAX_ATOMIC_COUNTERS;
 699
 700    /* GL_ARB_vertex_attrib_binding */
 701    consts->MaxVertexAttribRelativeOffset = 2047;
 702    consts->MaxVertexAttribBindings = MAX_VERTEX_GENERIC_ATTRIBS;
 703
 704    /* GL_ARB_compute_shader */
 705    consts->MaxComputeWorkGroupCount[0] = 65535;
 706    consts->MaxComputeWorkGroupCount[1] = 65535;
 707    consts->MaxComputeWorkGroupCount[2] = 65535;
 708    consts->MaxComputeWorkGroupSize[0] = 1024;
 709    consts->MaxComputeWorkGroupSize[1] = 1024;
 710    consts->MaxComputeWorkGroupSize[2] = 64;
 711    /* Enables compute support for GLES 3.1 if >= 128 */
 712    consts->MaxComputeWorkGroupInvocations = 0;
 713
 714    /** GL_ARB_gpu_shader5 */
 715    consts->MinFragmentInterpolationOffset = MIN_FRAGMENT_INTERPOLATION_OFFSET;
 716    consts->MaxFragmentInterpolationOffset = MAX_FRAGMENT_INTERPOLATION_OFFSET;
 717
 718    /** GL_KHR_context_flush_control */
 719    consts->ContextReleaseBehavior = GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH;
 720
 721    /** GL_ARB_tessellation_shader */
 722    consts->MaxTessGenLevel = MAX_TESS_GEN_LEVEL;
 723    consts->MaxPatchVertices = MAX_PATCH_VERTICES;
 724    consts->Program[MESA_SHADER_TESS_CTRL].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 725    consts->Program[MESA_SHADER_TESS_EVAL].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 726    consts->MaxTessPatchComponents = MAX_TESS_PATCH_COMPONENTS;
 727    consts->MaxTessControlTotalOutputComponents = MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS;
 728    consts->PrimitiveRestartForPatches = false;
 729
 730    /** GL_ARB_compute_variable_group_size */
 731    consts->MaxComputeVariableGroupSize[0] = 512;
 732    consts->MaxComputeVariableGroupSize[1] = 512;
 733    consts->MaxComputeVariableGroupSize[2] = 64;
 734    consts->MaxComputeVariableGroupInvocations = 512;
 735
 736    /** GL_NV_conservative_raster */
 737    consts->MaxSubpixelPrecisionBiasBits = 0;
 738
 739    /** GL_NV_conservative_raster_dilate */
 740    consts->ConservativeRasterDilateRange[0] = 0.0;
 741    consts->ConservativeRasterDilateRange[1] = 0.0;
 742    consts->ConservativeRasterDilateGranularity = 0.0;
 743 }
 744
 745
 746 /**
 747  * Do some sanity checks on the limits/constants for the given context.
 748  * Only called the first time a context is bound.
 749  */
 750 static void
 751 check_context_limits(struct gl_context *ctx)
 752 {
 753    (void) ctx;
 754
 755    /* check that we don't exceed the size of various bitfields */
 756    assert(VARYING_SLOT_MAX <=
 757           (8 * sizeof(ctx->VertexProgram._Current->info.outputs_written)));
 758    assert(VARYING_SLOT_MAX <=
 759           (8 * sizeof(ctx->FragmentProgram._Current->info.inputs_read)));
 760
 761    /* shader-related checks */
 762    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
 763    assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
 764
 765    /* Texture unit checks */
 766    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits > 0);
 767    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
 768    assert(ctx->Const.MaxTextureCoordUnits > 0);
 769    assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
 770    assert(ctx->Const.MaxTextureUnits > 0);
 771    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
 772    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
 773    assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits,
 774                                              ctx->Const.MaxTextureCoordUnits));
 775    assert(ctx->Const.MaxCombinedTextureImageUnits > 0);
 776    assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
 777    assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
 778    /* number of coord units cannot be greater than number of image units */
 779    assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
 780
 781
 782    /* Texture size checks */
 783    assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
 784    assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
 785    assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
 786    assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
 787
 788    /* Texture level checks */
 789    assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
 790    assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
 791
 792    /* Max texture size should be <= max viewport size (render to texture) */
 793    assert((1U << (ctx->Const.MaxTextureLevels - 1))
 794           <= ctx->Const.MaxViewportWidth);
 795    assert((1U << (ctx->Const.MaxTextureLevels - 1))
 796           <= ctx->Const.MaxViewportHeight);
 797
 798    assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
 799
 800    /* if this fails, add more enum values to gl_buffer_index */
 801    assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);
 802
 803    /* XXX probably add more tests */
 804 }
 805
 806
 807 /**
 808  * Initialize the attribute groups in a GL context.
 809  *
 810  * \param ctx GL context.
 811  *
 812  * Initializes all the attributes, calling the respective <tt>init*</tt>
 813  * functions for the more complex data structures.
 814  */
 815 static GLboolean
 816 init_attrib_groups(struct gl_context *ctx)
 817 {
 818    assert(ctx);
 819
 820    /* Constants */
 821    _mesa_init_constants(&ctx->Const, ctx->API);
 822
 823    /* Extensions */
 824    _mesa_init_extensions(&ctx->Extensions);
 825
 826    /* Attribute Groups */
 827    _mesa_init_accum( ctx );
 828    _mesa_init_attrib( ctx );
 829    _mesa_init_bbox( ctx );
 830    _mesa_init_buffer_objects( ctx );
 831    _mesa_init_color( ctx );
 832    _mesa_init_conservative_raster( ctx );
 833    _mesa_init_current( ctx );
 834    _mesa_init_depth( ctx );
 835    _mesa_init_debug( ctx );
 836    _mesa_init_debug_output( ctx );
 837    _mesa_init_display_list( ctx );
 838    _mesa_init_eval( ctx );
 839    _mesa_init_fbobjects( ctx );
 840    _mesa_init_feedback( ctx );
 841    _mesa_init_fog( ctx );
 842    _mesa_init_hint( ctx );
 843    _mesa_init_image_units( ctx );
 844    _mesa_init_line( ctx );
 845    _mesa_init_lighting( ctx );
 846    _mesa_init_matrix( ctx );
 847    _mesa_init_multisample( ctx );
 848    _mesa_init_performance_monitors( ctx );
 849    _mesa_init_performance_queries( ctx );
 850    _mesa_init_pipeline( ctx );
 851    _mesa_init_pixel( ctx );
 852    _mesa_init_pixelstore( ctx );
 853    _mesa_init_point( ctx );
 854    _mesa_init_polygon( ctx );
 855    _mesa_init_program( ctx );
 856    _mesa_init_queryobj( ctx );
 857    _mesa_init_sync( ctx );
 858    _mesa_init_rastpos( ctx );
 859    _mesa_init_scissor( ctx );
 860    _mesa_init_shader_state( ctx );
 861    _mesa_init_stencil( ctx );
 862    _mesa_init_transform( ctx );
 863    _mesa_init_transform_feedback( ctx );
 864    _mesa_init_varray( ctx );
 865    _mesa_init_viewport( ctx );
 866    _mesa_init_resident_handles( ctx );
 867
 868    if (!_mesa_init_texture( ctx ))
 869       return GL_FALSE;
 870
 871    /* Miscellaneous */
 872    ctx->TileRasterOrderIncreasingX = GL_TRUE;
 873    ctx->TileRasterOrderIncreasingY = GL_TRUE;
 874    ctx->NewState = _NEW_ALL;
 875    ctx->NewDriverState = ~0;
 876    ctx->ErrorValue = GL_NO_ERROR;
 877    ctx->ShareGroupReset = false;
 878    ctx->varying_vp_inputs = VERT_BIT_ALL;
 879
 880    return GL_TRUE;
 881 }
 882
 883
 884 /**
 885  * Update default objects in a GL context with respect to shared state.
 886  *
 887  * \param ctx GL context.
 888  *
 889  * Removes references to old default objects, (texture objects, program
 890  * objects, etc.) and changes to reference those from the current shared
 891  * state.
 892  */
 893 static GLboolean
 894 update_default_objects(struct gl_context *ctx)
 895 {
 896    assert(ctx);
 897
 898    _mesa_update_default_objects_program(ctx);
 899    _mesa_update_default_objects_texture(ctx);
 900    _mesa_update_default_objects_buffer_objects(ctx);
 901
 902    return GL_TRUE;
 903 }
 904
 905
 906 /* XXX this is temporary and should be removed at some point in the
 907  * future when there's a reasonable expectation that the libGL library
 908  * contains the _glapi_new_nop_table() and _glapi_set_nop_handler()
 909  * functions which were added in Mesa 10.6.
 910  */
 911 #if !defined(_WIN32)
 912 /* Avoid libGL / driver ABI break */
 913 #define USE_GLAPI_NOP_FEATURES 0
 914 #else
 915 #define USE_GLAPI_NOP_FEATURES 1
 916 #endif
 917
 918
 919 /**
 920  * This function is called by the glapi no-op functions.  For each OpenGL
 921  * function/entrypoint there's a simple no-op function.  These "no-op"
 922  * functions call this function.
 923  *
 924  * If there's a current OpenGL context for the calling thread, we record a
 925  * GL_INVALID_OPERATION error.  This can happen either because the app's
 926  * calling an unsupported extension function, or calling an illegal function
 927  * (such as glClear between glBegin/glEnd).
 928  *
 929  * If there's no current OpenGL context for the calling thread, we can
 930  * print a message to stderr.
 931  *
 932  * \param name  the name of the OpenGL function
 933  */
 934 #if USE_GLAPI_NOP_FEATURES
 935 static void
 936 nop_handler(const char *name)
 937 {
 938    GET_CURRENT_CONTEXT(ctx);
 939    if (ctx) {
 940       _mesa_error(ctx, GL_INVALID_OPERATION, "%s(invalid call)", name);
 941    }
 942 #if defined(DEBUG)
 943    else if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG")) {
 944       fprintf(stderr,
 945               "GL User Error: gl%s called without a rendering context\n",
 946               name);
 947       fflush(stderr);
 948    }
 949 #endif
 950 }
 951 #endif
 952
 953
 954 /**
 955  * Special no-op glFlush, see below.
 956  */
 957 #if defined(_WIN32)
 958 static void GLAPIENTRY
 959 nop_glFlush(void)
 960 {
 961    /* don't record an error like we do in nop_handler() */
 962 }
 963 #endif
 964
 965
 966 #if !USE_GLAPI_NOP_FEATURES
 967 static int
 968 generic_nop(void)
 969 {
 970    GET_CURRENT_CONTEXT(ctx);
 971    _mesa_error(ctx, GL_INVALID_OPERATION,
 972                "unsupported function called "
 973                "(unsupported extension or deprecated function?)");
 974    return 0;
 975 }
 976 #endif
 977
 978
 979 /**
 980  * Create a new API dispatch table in which all entries point to the
 981  * generic_nop() function.  This will not work on Windows because of
 982  * the __stdcall convention which requires the callee to clean up the
 983  * call stack.  That's impossible with one generic no-op function.
 984  */
 985 struct _glapi_table *
 986 _mesa_new_nop_table(unsigned numEntries)
 987 {
 988    struct _glapi_table *table;
 989
 990 #if !USE_GLAPI_NOP_FEATURES
 991    table = malloc(numEntries * sizeof(_glapi_proc));
 992    if (table) {
 993       _glapi_proc *entry = (_glapi_proc *) table;
 994       unsigned i;
 995       for (i = 0; i < numEntries; i++) {
 996          entry[i] = (_glapi_proc) generic_nop;
 997       }
 998    }
 999 #else
1000    table = _glapi_new_nop_table(numEntries);
1001 #endif
1002    return table;
1003 }
1004
1005
1006 /**
1007  * Allocate and initialize a new dispatch table.  The table will be
1008  * populated with pointers to "no-op" functions.  In turn, the no-op
1009  * functions will call nop_handler() above.
1010  */
1011 struct _glapi_table *
1012 _mesa_alloc_dispatch_table(void)
1013 {
1014    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1015     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
1016     * Mesa we do this to accommodate different versions of libGL and various
1017     * DRI drivers.
1018     */
1019    int numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);
1020
1021    struct _glapi_table *table = _mesa_new_nop_table(numEntries);
1022
1023 #if defined(_WIN32)
1024    if (table) {
1025       /* This is a special case for Windows in the event that
1026        * wglGetProcAddress is called between glBegin/End().
1027        *
1028        * The MS opengl32.dll library apparently calls glFlush from
1029        * wglGetProcAddress().  If we're inside glBegin/End(), glFlush
1030        * will dispatch to _mesa_generic_nop() and we'll generate a
1031        * GL_INVALID_OPERATION error.
1032        *
1033        * The specific case which hits this is piglit's primitive-restart
1034        * test which calls glPrimitiveRestartNV() inside glBegin/End.  The
1035        * first time we call glPrimitiveRestartNV() Piglit's API dispatch
1036        * code will try to resolve the function by calling wglGetProcAddress.
1037        * This raises GL_INVALID_OPERATION and an assert(glGetError()==0)
1038        * will fail causing the test to fail.  By suppressing the error, the
1039        * assertion passes and the test continues.
1040        */
1041       SET_Flush(table, nop_glFlush);
1042    }
1043 #endif
1044
1045 #if USE_GLAPI_NOP_FEATURES
1046    _glapi_set_nop_handler(nop_handler);
1047 #endif
1048
1049    return table;
1050 }
1051
1052 /**
1053  * Creates a minimal dispatch table for use within glBegin()/glEnd().
1054  *
1055  * This ensures that we generate GL_INVALID_OPERATION errors from most
1056  * functions, since the set of functions that are valid within Begin/End is
1057  * very small.
1058  *
1059  * From the GL 1.0 specification section 2.6.3, "GL Commands within
1060  * Begin/End"
1061  *
1062  *     "The only GL commands that are allowed within any Begin/End pairs are
1063  *      the commands for specifying vertex coordinates, vertex color, normal
1064  *      coordinates, and texture coordinates (Vertex, Color, Index, Normal,
1065  *      TexCoord), EvalCoord and EvalPoint commands (see section 5.1),
1066  *      commands for specifying lighting material parameters (Material
1067  *      commands see section 2.12.2), display list invocation commands
1068  *      (CallList and CallLists see section 5.4), and the EdgeFlag
1069  *      command. Executing Begin after Begin has already been executed but
1070  *      before an End is issued generates the INVALID OPERATION error, as does
1071  *      executing End without a previous corresponding Begin. Executing any
1072  *      other GL command within Begin/End results in the error INVALID
1073  *      OPERATION."
1074  *
1075  * The table entries for specifying vertex attributes are set up by
1076  * install_vtxfmt() and _mesa_loopback_init_api_table(), and End() and dlists
1077  * are set by install_vtxfmt() as well.
1078  */
1079 static struct _glapi_table *
1080 create_beginend_table(const struct gl_context *ctx)
1081 {
1082    struct _glapi_table *table;
1083
1084    table = _mesa_alloc_dispatch_table();
1085    if (!table)
1086       return NULL;
1087
1088    /* Fill in functions which return a value, since they should return some
1089     * specific value even if they emit a GL_INVALID_OPERATION error from them
1090     * being called within glBegin()/glEnd().
1091     */
1092 #define COPY_DISPATCH(func) SET_##func(table, GET_##func(ctx->Exec))
1093
1094    COPY_DISPATCH(GenLists);
1095    COPY_DISPATCH(IsProgram);
1096    COPY_DISPATCH(IsVertexArray);
1097    COPY_DISPATCH(IsBuffer);
1098    COPY_DISPATCH(IsEnabled);
1099    COPY_DISPATCH(IsEnabledi);
1100    COPY_DISPATCH(IsRenderbuffer);
1101    COPY_DISPATCH(IsFramebuffer);
1102    COPY_DISPATCH(CheckFramebufferStatus);
1103    COPY_DISPATCH(RenderMode);
1104    COPY_DISPATCH(GetString);
1105    COPY_DISPATCH(GetStringi);
1106    COPY_DISPATCH(GetPointerv);
1107    COPY_DISPATCH(IsQuery);
1108    COPY_DISPATCH(IsSampler);
1109    COPY_DISPATCH(IsSync);
1110    COPY_DISPATCH(IsTexture);
1111    COPY_DISPATCH(IsTransformFeedback);
1112    COPY_DISPATCH(DeleteQueries);
1113    COPY_DISPATCH(AreTexturesResident);
1114    COPY_DISPATCH(FenceSync);
1115    COPY_DISPATCH(ClientWaitSync);
1116    COPY_DISPATCH(MapBuffer);
1117    COPY_DISPATCH(UnmapBuffer);
1118    COPY_DISPATCH(MapBufferRange);
1119    COPY_DISPATCH(ObjectPurgeableAPPLE);
1120    COPY_DISPATCH(ObjectUnpurgeableAPPLE);
1121
1122    _mesa_loopback_init_api_table(ctx, table);
1123
1124    return table;
1125 }
1126
1127 void
1128 _mesa_initialize_dispatch_tables(struct gl_context *ctx)
1129 {
1130    /* Do the code-generated setup of the exec table in api_exec.c. */
1131    _mesa_initialize_exec_table(ctx);
1132
1133    if (ctx->Save)
1134       _mesa_initialize_save_table(ctx);
1135 }
1136
1137 /**
1138  * Initialize a struct gl_context struct (rendering context).
1139  *
1140  * This includes allocating all the other structs and arrays which hang off of
1141  * the context by pointers.
1142  * Note that the driver needs to pass in its dd_function_table here since
1143  * we need to at least call driverFunctions->NewTextureObject to create the
1144  * default texture objects.
1145  *
1146  * Called by _mesa_create_context().
1147  *
1148  * Performs the imports and exports callback tables initialization, and
1149  * miscellaneous one-time initializations. If no shared context is supplied one
1150  * is allocated, and increase its reference count.  Setups the GL API dispatch
1151  * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
1152  * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1153  * for debug flags.
1154  *
1155  * \param ctx the context to initialize
1156  * \param api the GL API type to create the context for
1157  * \param visual describes the visual attributes for this context or NULL to
1158  *               create a configless context
1159  * \param share_list points to context to share textures, display lists,
1160  *        etc with, or NULL
1161  * \param driverFunctions table of device driver functions for this context
1162  *        to use
1163  */
1164 GLboolean
1165 _mesa_initialize_context(struct gl_context *ctx,
1166                          gl_api api,
1167                          const struct gl_config *visual,
1168                          struct gl_context *share_list,
1169                          const struct dd_function_table *driverFunctions)
1170 {
1171    struct gl_shared_state *shared;
1172    int i;
1173
1174    assert(driverFunctions->NewTextureObject);
1175    assert(driverFunctions->FreeTextureImageBuffer);
1176
1177    ctx->API = api;
1178    ctx->DrawBuffer = NULL;
1179    ctx->ReadBuffer = NULL;
1180    ctx->WinSysDrawBuffer = NULL;
1181    ctx->WinSysReadBuffer = NULL;
1182
1183    if (visual) {
1184       ctx->Visual = *visual;
1185       ctx->HasConfig = GL_TRUE;
1186    }
1187    else {
1188       memset(&ctx->Visual, 0, sizeof ctx->Visual);
1189       ctx->HasConfig = GL_FALSE;
1190    }
1191
1192    _mesa_override_gl_version(ctx);
1193
1194    /* misc one-time initializations */
1195    one_time_init(ctx);
1196
1197    /* Plug in driver functions and context pointer here.
1198     * This is important because when we call alloc_shared_state() below
1199     * we'll call ctx->Driver.NewTextureObject() to create the default
1200     * textures.
1201     */
1202    ctx->Driver = *driverFunctions;
1203
1204    if (share_list) {
1205       /* share state with another context */
1206       shared = share_list->Shared;
1207    }
1208    else {
1209       /* allocate new, unshared state */
1210       shared = _mesa_alloc_shared_state(ctx);
1211       if (!shared)
1212          return GL_FALSE;
1213    }
1214
1215    _mesa_reference_shared_state(ctx, &ctx->Shared, shared);
1216
1217    if (!init_attrib_groups( ctx ))
1218       goto fail;
1219
1220    /* KHR_no_error is likely to crash, overflow memory, etc if an application
1221     * has errors so don't enable it for setuid processes.
1222     */
1223    if (env_var_as_boolean("MESA_NO_ERROR", false)) {
1224 #if !defined(_WIN32)
1225       if (geteuid() == getuid())
1226 #endif
1227          ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR;
1228    }
1229
1230    /* setup the API dispatch tables with all nop functions */
1231    ctx->OutsideBeginEnd = _mesa_alloc_dispatch_table();
1232    if (!ctx->OutsideBeginEnd)
1233       goto fail;
1234    ctx->Exec = ctx->OutsideBeginEnd;
1235    ctx->CurrentClientDispatch = ctx->CurrentServerDispatch = ctx->OutsideBeginEnd;
1236
1237    ctx->FragmentProgram._MaintainTexEnvProgram
1238       = (getenv("MESA_TEX_PROG") != NULL);
1239
1240    ctx->VertexProgram._MaintainTnlProgram
1241       = (getenv("MESA_TNL_PROG") != NULL);
1242    if (ctx->VertexProgram._MaintainTnlProgram) {
1243       /* this is required... */
1244       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1245    }
1246
1247    /* Mesa core handles all the formats that mesa core knows about.
1248     * Drivers will want to override this list with just the formats
1249     * they can handle, and confirm that appropriate fallbacks exist in
1250     * _mesa_choose_tex_format().
1251     */
1252    memset(&ctx->TextureFormatSupported, GL_TRUE,
1253           sizeof(ctx->TextureFormatSupported));
1254
1255    switch (ctx->API) {
1256    case API_OPENGL_COMPAT:
1257       ctx->BeginEnd = create_beginend_table(ctx);
1258       ctx->Save = _mesa_alloc_dispatch_table();
1259       if (!ctx->BeginEnd || !ctx->Save)
1260          goto fail;
1261
1262       /* fall-through */
1263    case API_OPENGL_CORE:
1264       break;
1265    case API_OPENGLES:
1266       /**
1267        * GL_OES_texture_cube_map says
1268        * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
1269        */
1270       for (i = 0; i < ARRAY_SIZE(ctx->Texture.FixedFuncUnit); i++) {
1271          struct gl_fixedfunc_texture_unit *texUnit =
1272             &ctx->Texture.FixedFuncUnit[i];
1273
1274          texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
1275          texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
1276          texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
1277          texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1278          texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1279          texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1280       }
1281       break;
1282    case API_OPENGLES2:
1283       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1284       ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
1285       break;
1286    }
1287
1288    ctx->FirstTimeCurrent = GL_TRUE;
1289
1290    return GL_TRUE;
1291
1292 fail:
1293    _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1294    free(ctx->BeginEnd);
1295    free(ctx->OutsideBeginEnd);
1296    free(ctx->Save);
1297    return GL_FALSE;
1298 }
1299
1300
1301 /**
1302  * Free the data associated with the given context.
1303  *
1304  * But doesn't free the struct gl_context struct itself.
1305  *
1306  * \sa _mesa_initialize_context() and init_attrib_groups().
1307  */
1308 void
1309 _mesa_free_context_data( struct gl_context *ctx )
1310 {
1311    if (!_mesa_get_current_context()){
1312       /* No current context, but we may need one in order to delete
1313        * texture objs, etc.  So temporarily bind the context now.
1314        */
1315       _mesa_make_current(ctx, NULL, NULL);
1316    }
1317
1318    /* unreference WinSysDraw/Read buffers */
1319    _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
1320    _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
1321    _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
1322    _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
1323
1324    _mesa_reference_program(ctx, &ctx->VertexProgram.Current, NULL);
1325    _mesa_reference_program(ctx, &ctx->VertexProgram._Current, NULL);
1326    _mesa_reference_program(ctx, &ctx->VertexProgram._TnlProgram, NULL);
1327
1328    _mesa_reference_program(ctx, &ctx->TessCtrlProgram._Current, NULL);
1329    _mesa_reference_program(ctx, &ctx->TessEvalProgram._Current, NULL);
1330    _mesa_reference_program(ctx, &ctx->GeometryProgram._Current, NULL);
1331
1332    _mesa_reference_program(ctx, &ctx->FragmentProgram.Current, NULL);
1333    _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, NULL);
1334    _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
1335
1336    _mesa_reference_program(ctx, &ctx->ComputeProgram._Current, NULL);
1337
1338    _mesa_reference_vao(ctx, &ctx->Array.VAO, NULL);
1339    _mesa_reference_vao(ctx, &ctx->Array.DefaultVAO, NULL);
1340    _mesa_reference_vao(ctx, &ctx->Array._EmptyVAO, NULL);
1341    _mesa_reference_vao(ctx, &ctx->Array._DrawVAO, NULL);
1342
1343    _mesa_free_attrib_data(ctx);
1344    _mesa_free_buffer_objects(ctx);
1345    _mesa_free_eval_data( ctx );
1346    _mesa_free_texture_data( ctx );
1347    _mesa_free_matrix_data( ctx );
1348    _mesa_free_pipeline_data(ctx);
1349    _mesa_free_program_data(ctx);
1350    _mesa_free_shader_state(ctx);
1351    _mesa_free_queryobj_data(ctx);
1352    _mesa_free_sync_data(ctx);
1353    _mesa_free_varray_data(ctx);
1354    _mesa_free_transform_feedback(ctx);
1355    _mesa_free_performance_monitors(ctx);
1356    _mesa_free_performance_queries(ctx);
1357    _mesa_free_resident_handles(ctx);
1358
1359    _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
1360    _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
1361    _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
1362    _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
1363
1364    /* free dispatch tables */
1365    free(ctx->BeginEnd);
1366    free(ctx->OutsideBeginEnd);
1367    free(ctx->Save);
1368    free(ctx->ContextLost);
1369    free(ctx->MarshalExec);
1370
1371    /* Shared context state (display lists, textures, etc) */
1372    _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1373
1374    /* needs to be after freeing shared state */
1375    _mesa_free_display_list_data(ctx);
1376
1377    _mesa_free_errors_data(ctx);
1378
1379    free((void *)ctx->Extensions.String);
1380
1381    free(ctx->VersionString);
1382
1383    /* unbind the context if it's currently bound */
1384    if (ctx == _mesa_get_current_context()) {
1385       _mesa_make_current(NULL, NULL, NULL);
1386    }
1387 }
1388
1389
1390 /**
1391  * Destroy a struct gl_context structure.
1392  *
1393  * \param ctx GL context.
1394  *
1395  * Calls _mesa_free_context_data() and frees the gl_context object itself.
1396  */
1397 void
1398 _mesa_destroy_context( struct gl_context *ctx )
1399 {
1400    if (ctx) {
1401       _mesa_free_context_data(ctx);
1402       free( (void *) ctx );
1403    }
1404 }
1405
1406
1407 /**
1408  * Copy attribute groups from one context to another.
1409  *
1410  * \param src source context
1411  * \param dst destination context
1412  * \param mask bitwise OR of GL_*_BIT flags
1413  *
1414  * According to the bits specified in \p mask, copies the corresponding
1415  * attributes from \p src into \p dst.  For many of the attributes a simple \c
1416  * memcpy is not enough due to the existence of internal pointers in their data
1417  * structures.
1418  */
1419 void
1420 _mesa_copy_context( const struct gl_context *src, struct gl_context *dst,
1421                     GLuint mask )
1422 {
1423    if (mask & GL_ACCUM_BUFFER_BIT) {
1424       /* OK to memcpy */
1425       dst->Accum = src->Accum;
1426    }
1427    if (mask & GL_COLOR_BUFFER_BIT) {
1428       /* OK to memcpy */
1429       dst->Color = src->Color;
1430    }
1431    if (mask & GL_CURRENT_BIT) {
1432       /* OK to memcpy */
1433       dst->Current = src->Current;
1434    }
1435    if (mask & GL_DEPTH_BUFFER_BIT) {
1436       /* OK to memcpy */
1437       dst->Depth = src->Depth;
1438    }
1439    if (mask & GL_ENABLE_BIT) {
1440       /* no op */
1441    }
1442    if (mask & GL_EVAL_BIT) {
1443       /* OK to memcpy */
1444       dst->Eval = src->Eval;
1445    }
1446    if (mask & GL_FOG_BIT) {
1447       /* OK to memcpy */
1448       dst->Fog = src->Fog;
1449    }
1450    if (mask & GL_HINT_BIT) {
1451       /* OK to memcpy */
1452       dst->Hint = src->Hint;
1453    }
1454    if (mask & GL_LIGHTING_BIT) {
1455       /* OK to memcpy */
1456       dst->Light = src->Light;
1457    }
1458    if (mask & GL_LINE_BIT) {
1459       /* OK to memcpy */
1460       dst->Line = src->Line;
1461    }
1462    if (mask & GL_LIST_BIT) {
1463       /* OK to memcpy */
1464       dst->List = src->List;
1465    }
1466    if (mask & GL_PIXEL_MODE_BIT) {
1467       /* OK to memcpy */
1468       dst->Pixel = src->Pixel;
1469    }
1470    if (mask & GL_POINT_BIT) {
1471       /* OK to memcpy */
1472       dst->Point = src->Point;
1473    }
1474    if (mask & GL_POLYGON_BIT) {
1475       /* OK to memcpy */
1476       dst->Polygon = src->Polygon;
1477    }
1478    if (mask & GL_POLYGON_STIPPLE_BIT) {
1479       /* Use loop instead of memcpy due to problem with Portland Group's
1480        * C compiler.  Reported by John Stone.
1481        */
1482       GLuint i;
1483       for (i = 0; i < 32; i++) {
1484          dst->PolygonStipple[i] = src->PolygonStipple[i];
1485       }
1486    }
1487    if (mask & GL_SCISSOR_BIT) {
1488       /* OK to memcpy */
1489       dst->Scissor = src->Scissor;
1490    }
1491    if (mask & GL_STENCIL_BUFFER_BIT) {
1492       /* OK to memcpy */
1493       dst->Stencil = src->Stencil;
1494    }
1495    if (mask & GL_TEXTURE_BIT) {
1496       /* Cannot memcpy because of pointers */
1497       _mesa_copy_texture_state(src, dst);
1498    }
1499    if (mask & GL_TRANSFORM_BIT) {
1500       /* OK to memcpy */
1501       dst->Transform = src->Transform;
1502    }
1503    if (mask & GL_VIEWPORT_BIT) {
1504       unsigned i;
1505       for (i = 0; i < src->Const.MaxViewports; i++) {
1506          /* OK to memcpy */
1507          dst->ViewportArray[i] = src->ViewportArray[i];
1508       }
1509    }
1510
1511    /* XXX FIXME:  Call callbacks?
1512     */
1513    dst->NewState = _NEW_ALL;
1514    dst->NewDriverState = ~0;
1515 }
1516
1517
1518 /**
1519  * Check if the given context can render into the given framebuffer
1520  * by checking visual attributes.
1521  *
1522  * \return GL_TRUE if compatible, GL_FALSE otherwise.
1523  */
1524 static GLboolean
1525 check_compatible(const struct gl_context *ctx,
1526                  const struct gl_framebuffer *buffer)
1527 {
1528    const struct gl_config *ctxvis = &ctx->Visual;
1529    const struct gl_config *bufvis = &buffer->Visual;
1530
1531    if (buffer == _mesa_get_incomplete_framebuffer())
1532       return GL_TRUE;
1533
1534 #define check_component(foo)           \
1535    if (ctxvis->foo && bufvis->foo &&   \
1536        ctxvis->foo != bufvis->foo)     \
1537       return GL_FALSE
1538
1539    check_component(redMask);
1540    check_component(greenMask);
1541    check_component(blueMask);
1542    check_component(depthBits);
1543    check_component(stencilBits);
1544
1545 #undef check_component
1546
1547    return GL_TRUE;
1548 }
1549
1550
1551 /**
1552  * Check if the viewport/scissor size has not yet been initialized.
1553  * Initialize the size if the given width and height are non-zero.
1554  */
1555 static void
1556 check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
1557 {
1558    if (!ctx->ViewportInitialized && width > 0 && height > 0) {
1559       unsigned i;
1560
1561       /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
1562        * potential infinite recursion.
1563        */
1564       ctx->ViewportInitialized = GL_TRUE;
1565
1566       /* Note: ctx->Const.MaxViewports may not have been set by the driver
1567        * yet, so just initialize all of them.
1568        */
1569       for (i = 0; i < MAX_VIEWPORTS; i++) {
1570          _mesa_set_viewport(ctx, i, 0, 0, width, height);
1571          _mesa_set_scissor(ctx, i, 0, 0, width, height);
1572       }
1573    }
1574 }
1575
1576
1577 static void
1578 handle_first_current(struct gl_context *ctx)
1579 {
1580    if (ctx->Version == 0 || !ctx->DrawBuffer) {
1581       /* probably in the process of tearing down the context */
1582       return;
1583    }
1584
1585    check_context_limits(ctx);
1586
1587    _mesa_update_vertex_processing_mode(ctx);
1588
1589    /* According to GL_MESA_configless_context the default value of
1590     * glDrawBuffers depends on the config of the first surface it is bound to.
1591     * For GLES it is always GL_BACK which has a magic interpretation.
1592     */
1593    if (!ctx->HasConfig && _mesa_is_desktop_gl(ctx)) {
1594       if (ctx->DrawBuffer != _mesa_get_incomplete_framebuffer()) {
1595          GLenum16 buffer;
1596
1597          if (ctx->DrawBuffer->Visual.doubleBufferMode)
1598             buffer = GL_BACK;
1599          else
1600             buffer = GL_FRONT;
1601
1602          _mesa_drawbuffers(ctx, ctx->DrawBuffer, 1, &buffer,
1603                            NULL /* destMask */);
1604       }
1605
1606       if (ctx->ReadBuffer != _mesa_get_incomplete_framebuffer()) {
1607          gl_buffer_index bufferIndex;
1608          GLenum buffer;
1609
1610          if (ctx->ReadBuffer->Visual.doubleBufferMode) {
1611             buffer = GL_BACK;
1612             bufferIndex = BUFFER_BACK_LEFT;
1613          }
1614          else {
1615             buffer = GL_FRONT;
1616             bufferIndex = BUFFER_FRONT_LEFT;
1617          }
1618
1619          _mesa_readbuffer(ctx, ctx->ReadBuffer, buffer, bufferIndex);
1620       }
1621    }
1622
1623    /* Determine if generic vertex attribute 0 aliases the conventional
1624     * glVertex position.
1625     */
1626    {
1627       const bool is_forward_compatible_context =
1628          ctx->Const.ContextFlags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT;
1629
1630       /* In OpenGL 3.1 attribute 0 becomes non-magic, just like in OpenGL ES
1631        * 2.0.  Note that we cannot just check for API_OPENGL_COMPAT here because
1632        * that will erroneously allow this usage in a 3.0 forward-compatible
1633        * context too.
1634        */
1635       ctx->_AttribZeroAliasesVertex = (ctx->API == API_OPENGLES
1636                                        || (ctx->API == API_OPENGL_COMPAT
1637                                            && !is_forward_compatible_context));
1638    }
1639
1640    /* We can use this to help debug user's problems.  Tell them to set
1641     * the MESA_INFO env variable before running their app.  Then the
1642     * first time each context is made current we'll print some useful
1643     * information.
1644     */
1645    if (getenv("MESA_INFO")) {
1646       _mesa_print_info(ctx);
1647    }
1648 }
1649
1650 /**
1651  * Bind the given context to the given drawBuffer and readBuffer and
1652  * make it the current context for the calling thread.
1653  * We'll render into the drawBuffer and read pixels from the
1654  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1655  *
1656  * We check that the context's and framebuffer's visuals are compatible
1657  * and return immediately if they're not.
1658  *
1659  * \param newCtx  the new GL context. If NULL then there will be no current GL
1660  *                context.
1661  * \param drawBuffer  the drawing framebuffer
1662  * \param readBuffer  the reading framebuffer
1663  */
1664 GLboolean
1665 _mesa_make_current( struct gl_context *newCtx,
1666                     struct gl_framebuffer *drawBuffer,
1667                     struct gl_framebuffer *readBuffer )
1668 {
1669    GET_CURRENT_CONTEXT(curCtx);
1670
1671    if (MESA_VERBOSE & VERBOSE_API)
1672       _mesa_debug(newCtx, "_mesa_make_current()\n");
1673
1674    /* Check that the context's and framebuffer's visuals are compatible.
1675     */
1676    if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1677       if (!check_compatible(newCtx, drawBuffer)) {
1678          _mesa_warning(newCtx,
1679               "MakeCurrent: incompatible visuals for context and drawbuffer");
1680          return GL_FALSE;
1681       }
1682    }
1683    if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1684       if (!check_compatible(newCtx, readBuffer)) {
1685          _mesa_warning(newCtx,
1686               "MakeCurrent: incompatible visuals for context and readbuffer");
1687          return GL_FALSE;
1688       }
1689    }
1690
1691    if (curCtx &&
1692        (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) &&
1693        /* make sure this context is valid for flushing */
1694        curCtx != newCtx &&
1695        curCtx->Const.ContextReleaseBehavior ==
1696        GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH) {
1697       _mesa_flush(curCtx);
1698    }
1699
1700    /* We used to call _glapi_check_multithread() here.  Now do it in drivers */
1701
1702    if (!newCtx) {
1703       _glapi_set_dispatch(NULL);  /* none current */
1704       /* We need old ctx to correctly release Draw/ReadBuffer
1705        * and avoid a surface leak in st_renderbuffer_delete.
1706        * Therefore, first drop buffers then set new ctx to NULL.
1707        */
1708       if (curCtx) {
1709          _mesa_reference_framebuffer(&curCtx->WinSysDrawBuffer, NULL);
1710          _mesa_reference_framebuffer(&curCtx->WinSysReadBuffer, NULL);
1711       }
1712       _glapi_set_context(NULL);
1713       assert(_mesa_get_current_context() == NULL);
1714    }
1715    else {
1716       _glapi_set_context((void *) newCtx);
1717       assert(_mesa_get_current_context() == newCtx);
1718       _glapi_set_dispatch(newCtx->CurrentClientDispatch);
1719
1720       if (drawBuffer && readBuffer) {
1721          assert(_mesa_is_winsys_fbo(drawBuffer));
1722          assert(_mesa_is_winsys_fbo(readBuffer));
1723          _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1724          _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1725
1726          /*
1727           * Only set the context's Draw/ReadBuffer fields if they're NULL
1728           * or not bound to a user-created FBO.
1729           */
1730          if (!newCtx->DrawBuffer || _mesa_is_winsys_fbo(newCtx->DrawBuffer)) {
1731             _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1732             /* Update the FBO's list of drawbuffers/renderbuffers.
1733              * For winsys FBOs this comes from the GL state (which may have
1734              * changed since the last time this FBO was bound).
1735              */
1736             _mesa_update_draw_buffers(newCtx);
1737          }
1738          if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) {
1739             _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1740             /* In _mesa_initialize_window_framebuffer, for single-buffered
1741              * visuals, the ColorReadBuffer is set to be GL_FRONT, even with
1742              * GLES contexts. When calling read_buffer, we verify we are reading
1743              * from GL_BACK in is_legal_es3_readbuffer_enum.  But the default is
1744              * incorrect, and certain dEQP tests check this.  So fix it here.
1745              */
1746             if (_mesa_is_gles(newCtx) &&
1747                !newCtx->ReadBuffer->Visual.doubleBufferMode)
1748                if (newCtx->ReadBuffer->ColorReadBuffer == GL_FRONT)
1749                   newCtx->ReadBuffer->ColorReadBuffer = GL_BACK;
1750          }
1751
1752          /* XXX only set this flag if we're really changing the draw/read
1753           * framebuffer bindings.
1754           */
1755          newCtx->NewState |= _NEW_BUFFERS;
1756
1757          check_init_viewport(newCtx, drawBuffer->Width, drawBuffer->Height);
1758       }
1759
1760       if (newCtx->FirstTimeCurrent) {
1761          handle_first_current(newCtx);
1762          newCtx->FirstTimeCurrent = GL_FALSE;
1763       }
1764    }
1765
1766    return GL_TRUE;
1767 }
1768
1769
1770 /**
1771  * Make context 'ctx' share the display lists, textures and programs
1772  * that are associated with 'ctxToShare'.
1773  * Any display lists, textures or programs associated with 'ctx' will
1774  * be deleted if nobody else is sharing them.
1775  */
1776 GLboolean
1777 _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
1778 {
1779    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1780       struct gl_shared_state *oldShared = NULL;
1781
1782       /* save ref to old state to prevent it from being deleted immediately */
1783       _mesa_reference_shared_state(ctx, &oldShared, ctx->Shared);
1784
1785       /* update ctx's Shared pointer */
1786       _mesa_reference_shared_state(ctx, &ctx->Shared, ctxToShare->Shared);
1787
1788       update_default_objects(ctx);
1789
1790       /* release the old shared state */
1791       _mesa_reference_shared_state(ctx, &oldShared, NULL);
1792
1793       return GL_TRUE;
1794    }
1795    else {
1796       return GL_FALSE;
1797    }
1798 }
1799
1800
1801
1802 /**
1803  * \return pointer to the current GL context for this thread.
1804  *
1805  * Calls _glapi_get_context(). This isn't the fastest way to get the current
1806  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
1807  * context.h.
1808  */
1809 struct gl_context *
1810 _mesa_get_current_context( void )
1811 {
1812    return (struct gl_context *) _glapi_get_context();
1813 }
1814
1815
1816 /**
1817  * Get context's current API dispatch table.
1818  *
1819  * It'll either be the immediate-mode execute dispatcher, the display list
1820  * compile dispatcher, or the thread marshalling dispatcher.
1821  *
1822  * \param ctx GL context.
1823  *
1824  * \return pointer to dispatch_table.
1825  *
1826  * Simply returns __struct gl_contextRec::CurrentClientDispatch.
1827  */
1828 struct _glapi_table *
1829 _mesa_get_dispatch(struct gl_context *ctx)
1830 {
1831    return ctx->CurrentClientDispatch;
1832 }
1833
1834 /*@}*/
1835
1836
1837 /**********************************************************************/
1838 /** \name Miscellaneous functions                                     */
1839 /**********************************************************************/
1840 /*@{*/
1841 /**
1842  * Flush commands.
1843  */
1844 void
1845 _mesa_flush(struct gl_context *ctx)
1846 {
1847    FLUSH_VERTICES( ctx, 0 );
1848    FLUSH_CURRENT( ctx, 0 );
1849    if (ctx->Driver.Flush) {
1850       ctx->Driver.Flush(ctx);
1851    }
1852 }
1853
1854
1855
1856 /**
1857  * Flush commands and wait for completion.
1858  *
1859  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1860  * dd_function_table::Finish driver callback, if not NULL.
1861  */
1862 void GLAPIENTRY
1863 _mesa_Finish(void)
1864 {
1865    GET_CURRENT_CONTEXT(ctx);
1866    ASSERT_OUTSIDE_BEGIN_END(ctx);
1867
1868    FLUSH_VERTICES(ctx, 0);
1869    FLUSH_CURRENT(ctx, 0);
1870
1871    if (ctx->Driver.Finish) {
1872       ctx->Driver.Finish(ctx);
1873    }
1874 }
1875
1876
1877 /**
1878  * Execute glFlush().
1879  *
1880  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1881  * dd_function_table::Flush driver callback, if not NULL.
1882  */
1883 void GLAPIENTRY
1884 _mesa_Flush(void)
1885 {
1886    GET_CURRENT_CONTEXT(ctx);
1887    ASSERT_OUTSIDE_BEGIN_END(ctx);
1888    _mesa_flush(ctx);
1889 }
1890
1891
1892 /*@}*/