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