src/mesa/main/context.c

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