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