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