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
  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/builtin_functions.h"
 153 #include "compiler/glsl/glsl_parser_extras.h"
 154 #include <stdbool.h>
 155 #include "util/u_memory.h"
 156
 157
 158 #ifndef MESA_VERBOSE
 159 int MESA_VERBOSE = 0;
 160 #endif
 161
 162 #ifndef MESA_DEBUG_FLAGS
 163 int MESA_DEBUG_FLAGS = 0;
 164 #endif
 165
 166
 167 /* ubyte -> float conversion */
 168 GLfloat _mesa_ubyte_to_float_color_tab[256];
 169
 170
 171
 172 /**
 173  * Swap buffers notification callback.
 174  *
 175  * \param ctx GL context.
 176  *
 177  * Called by window system just before swapping buffers.
 178  * We have to finish any pending rendering.
 179  */
 180 void
 181 _mesa_notifySwapBuffers(struct gl_context *ctx)
 182 {
 183    if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)
 184       _mesa_debug(ctx, "SwapBuffers\n");
 185    FLUSH_VERTICES(ctx, 0);
 186    if (ctx->Driver.Flush) {
 187       ctx->Driver.Flush(ctx);
 188    }
 189 }
 190
 191
 192 /**********************************************************************/
 193 /** \name GL Visual allocation/destruction                            */
 194 /**********************************************************************/
 195 /*@{*/
 196
 197 /**
 198  * Allocates a struct gl_config structure and initializes it via
 199  * _mesa_initialize_visual().
 200  *
 201  * \param dbFlag double buffering
 202  * \param stereoFlag stereo buffer
 203  * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
 204  * is acceptable but the actual depth type will be GLushort or GLuint as
 205  * needed.
 206  * \param stencilBits requested minimum bits per stencil buffer value
 207  * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number
 208  * of bits per color component in accum buffer.
 209  * \param redBits number of bits per color component in frame buffer for RGB(A)
 210  * mode.  We always use 8 in core Mesa though.
 211  * \param greenBits same as above.
 212  * \param blueBits same as above.
 213  * \param alphaBits same as above.
 214  * \param numSamples not really used.
 215  *
 216  * \return pointer to new struct gl_config or NULL if requested parameters
 217  * can't be met.
 218  *
 219  * \note Need to add params for level and numAuxBuffers (at least)
 220  */
 221 struct gl_config *
 222 _mesa_create_visual( GLboolean dbFlag,
 223                      GLboolean stereoFlag,
 224                      GLint redBits,
 225                      GLint greenBits,
 226                      GLint blueBits,
 227                      GLint alphaBits,
 228                      GLint depthBits,
 229                      GLint stencilBits,
 230                      GLint accumRedBits,
 231                      GLint accumGreenBits,
 232                      GLint accumBlueBits,
 233                      GLint accumAlphaBits,
 234                      GLuint numSamples )
 235 {
 236    struct gl_config *vis = CALLOC_STRUCT(gl_config);
 237    if (vis) {
 238       if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,
 239                                    redBits, greenBits, blueBits, alphaBits,
 240                                    depthBits, stencilBits,
 241                                    accumRedBits, accumGreenBits,
 242                                    accumBlueBits, accumAlphaBits,
 243                                    numSamples)) {
 244          free(vis);
 245          return NULL;
 246       }
 247    }
 248    return vis;
 249 }
 250
 251
 252 /**
 253  * Makes some sanity checks and fills in the fields of the struct
 254  * gl_config object with the given parameters.  If the caller needs to
 255  * set additional fields, he should just probably init the whole
 256  * gl_config object himself.
 257  *
 258  * \return GL_TRUE on success, or GL_FALSE on failure.
 259  *
 260  * \sa _mesa_create_visual() above for the parameter description.
 261  */
 262 GLboolean
 263 _mesa_initialize_visual( struct gl_config *vis,
 264                          GLboolean dbFlag,
 265                          GLboolean stereoFlag,
 266                          GLint redBits,
 267                          GLint greenBits,
 268                          GLint blueBits,
 269                          GLint alphaBits,
 270                          GLint depthBits,
 271                          GLint stencilBits,
 272                          GLint accumRedBits,
 273                          GLint accumGreenBits,
 274                          GLint accumBlueBits,
 275                          GLint accumAlphaBits,
 276                          GLuint numSamples )
 277 {
 278    assert(vis);
 279
 280    if (depthBits < 0 || depthBits > 32) {
 281       return GL_FALSE;
 282    }
 283    if (stencilBits < 0 || stencilBits > 8) {
 284       return GL_FALSE;
 285    }
 286    assert(accumRedBits >= 0);
 287    assert(accumGreenBits >= 0);
 288    assert(accumBlueBits >= 0);
 289    assert(accumAlphaBits >= 0);
 290
 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->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->numAuxBuffers = 0;
 309    vis->level = 0;
 310    vis->sampleBuffers = numSamples > 0 ? 1 : 0;
 311    vis->samples = numSamples;
 312
 313    return GL_TRUE;
 314 }
 315
 316
 317 /**
 318  * Destroy a visual and free its memory.
 319  *
 320  * \param vis visual.
 321  *
 322  * Frees the visual structure.
 323  */
 324 void
 325 _mesa_destroy_visual( struct gl_config *vis )
 326 {
 327    free(vis);
 328 }
 329
 330 /*@}*/
 331
 332
 333 /**********************************************************************/
 334 /** \name Context allocation, initialization, destroying
 335  *
 336  * The purpose of the most initialization functions here is to provide the
 337  * default state values according to the OpenGL specification.
 338  */
 339 /**********************************************************************/
 340 /*@{*/
 341
 342
 343 /**
 344  * Calls all the various one-time-fini functions in Mesa
 345  */
 346
 347 static void
 348 one_time_fini(void)
 349 {
 350    glsl_type_singleton_decref();
 351    _mesa_locale_fini();
 352 }
 353
 354 /**
 355  * Calls all the various one-time-init functions in Mesa
 356  */
 357
 358 static void
 359 one_time_init(void)
 360 {
 361    GLuint i;
 362
 363    STATIC_ASSERT(sizeof(GLbyte) == 1);
 364    STATIC_ASSERT(sizeof(GLubyte) == 1);
 365    STATIC_ASSERT(sizeof(GLshort) == 2);
 366    STATIC_ASSERT(sizeof(GLushort) == 2);
 367    STATIC_ASSERT(sizeof(GLint) == 4);
 368    STATIC_ASSERT(sizeof(GLuint) == 4);
 369
 370    _mesa_locale_init();
 371
 372    _mesa_one_time_init_extension_overrides();
 373
 374    _mesa_get_cpu_features();
 375
 376    for (i = 0; i < 256; i++) {
 377       _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
 378    }
 379
 380    atexit(one_time_fini);
 381
 382 #if defined(DEBUG)
 383    if (MESA_VERBOSE != 0) {
 384       _mesa_debug(NULL, "Mesa " PACKAGE_VERSION " DEBUG build" MESA_GIT_SHA1 "\n");
 385    }
 386 #endif
 387
 388    /* Take a glsl type reference for the duration of libGL's life to avoid
 389     * unecessary creation/destruction of glsl types.
 390     */
 391    glsl_type_singleton_init_or_ref();
 392
 393    _mesa_init_remap_table();
 394 }
 395
 396 /**
 397  * One-time initialization flag
 398  *
 399  * \sa Used by _mesa_initialize().
 400  */
 401 static once_flag init_once = ONCE_FLAG_INIT;
 402
 403
 404 /**
 405  * Calls all the various one-time-init functions in Mesa.
 406  *
 407  * While holding a global mutex lock, calls several initialization functions,
 408  * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
 409  * defined.
 410  *
 411  * \sa _math_init().
 412  */
 413 void
 414 _mesa_initialize(void)
 415 {
 416    call_once(&init_once, one_time_init);
 417 }
 418
 419
 420 /**
 421  * Initialize fields of gl_current_attrib (aka ctx->Current.*)
 422  */
 423 static void
 424 _mesa_init_current(struct gl_context *ctx)
 425 {
 426    GLuint i;
 427
 428    /* Init all to (0,0,0,1) */
 429    for (i = 0; i < ARRAY_SIZE(ctx->Current.Attrib); i++) {
 430       ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
 431    }
 432
 433    /* redo special cases: */
 434    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
 435    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
 436    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
 437    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
 438    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
 439 }
 440
 441
 442 /**
 443  * Init vertex/fragment/geometry program limits.
 444  * Important: drivers should override these with actual limits.
 445  */
 446 static void
 447 init_program_limits(struct gl_constants *consts, gl_shader_stage stage,
 448                     struct gl_program_constants *prog)
 449 {
 450    prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
 451    prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
 452    prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
 453    prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
 454    prog->MaxTemps = MAX_PROGRAM_TEMPS;
 455    prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
 456    prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
 457    prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS;
 458
 459    switch (stage) {
 460    case MESA_SHADER_VERTEX:
 461       prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
 462       prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;
 463       prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
 464       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 465       prog->MaxInputComponents = 0; /* value not used */
 466       prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */
 467       break;
 468    case MESA_SHADER_FRAGMENT:
 469       prog->MaxParameters = MAX_FRAGMENT_PROGRAM_PARAMS;
 470       prog->MaxAttribs = MAX_FRAGMENT_PROGRAM_INPUTS;
 471       prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
 472       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 473       prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */
 474       prog->MaxOutputComponents = 0; /* value not used */
 475       break;
 476    case MESA_SHADER_TESS_CTRL:
 477    case MESA_SHADER_TESS_EVAL:
 478    case MESA_SHADER_GEOMETRY:
 479       prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
 480       prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;
 481       prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
 482       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 483       prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */
 484       prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */
 485       break;
 486    case MESA_SHADER_COMPUTE:
 487       prog->MaxParameters = 0; /* not meaningful for compute shaders */
 488       prog->MaxAttribs = 0; /* not meaningful for compute shaders */
 489       prog->MaxAddressRegs = 0; /* not meaningful for compute shaders */
 490       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 491       prog->MaxInputComponents = 0; /* not meaningful for compute shaders */
 492       prog->MaxOutputComponents = 0; /* not meaningful for compute shaders */
 493       break;
 494    default:
 495       assert(0 && "Bad shader stage in init_program_limits()");
 496    }
 497
 498    /* Set the native limits to zero.  This implies that there is no native
 499     * support for shaders.  Let the drivers fill in the actual values.
 500     */
 501    prog->MaxNativeInstructions = 0;
 502    prog->MaxNativeAluInstructions = 0;
 503    prog->MaxNativeTexInstructions = 0;
 504    prog->MaxNativeTexIndirections = 0;
 505    prog->MaxNativeAttribs = 0;
 506    prog->MaxNativeTemps = 0;
 507    prog->MaxNativeAddressRegs = 0;
 508    prog->MaxNativeParameters = 0;
 509
 510    /* Set GLSL datatype range/precision info assuming IEEE float values.
 511     * Drivers should override these defaults as needed.
 512     */
 513    prog->MediumFloat.RangeMin = 127;
 514    prog->MediumFloat.RangeMax = 127;
 515    prog->MediumFloat.Precision = 23;
 516    prog->LowFloat = prog->HighFloat = prog->MediumFloat;
 517
 518    /* Assume ints are stored as floats for now, since this is the least-common
 519     * denominator.  The OpenGL ES spec implies (page 132) that the precision
 520     * of integer types should be 0.  Practically speaking, IEEE
 521     * single-precision floating point values can only store integers in the
 522     * range [-0x01000000, 0x01000000] without loss of precision.
 523     */
 524    prog->MediumInt.RangeMin = 24;
 525    prog->MediumInt.RangeMax = 24;
 526    prog->MediumInt.Precision = 0;
 527    prog->LowInt = prog->HighInt = prog->MediumInt;
 528
 529    prog->MaxUniformBlocks = 12;
 530    prog->MaxCombinedUniformComponents = (prog->MaxUniformComponents +
 531                                          consts->MaxUniformBlockSize / 4 *
 532                                          prog->MaxUniformBlocks);
 533
 534    prog->MaxAtomicBuffers = 0;
 535    prog->MaxAtomicCounters = 0;
 536
 537    prog->MaxShaderStorageBlocks = 8;
 538 }
 539
 540
 541 /**
 542  * Initialize fields of gl_constants (aka ctx->Const.*).
 543  * Use defaults from config.h.  The device drivers will often override
 544  * some of these values (such as number of texture units).
 545  */
 546 void
 547 _mesa_init_constants(struct gl_constants *consts, gl_api api)
 548 {
 549    int i;
 550    assert(consts);
 551
 552    /* Constants, may be overriden (usually only reduced) by device drivers */
 553    consts->MaxTextureMbytes = MAX_TEXTURE_MBYTES;
 554    consts->MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
 555    consts->Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
 556    consts->MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
 557    consts->MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
 558    consts->MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
 559    consts->MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
 560    consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 561    consts->MaxTextureUnits = MIN2(consts->MaxTextureCoordUnits,
 562                                      consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
 563    consts->MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
 564    consts->MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
 565    consts->MaxTextureBufferSize = 65536;
 566    consts->TextureBufferOffsetAlignment = 1;
 567    consts->MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
 568    consts->SubPixelBits = SUB_PIXEL_BITS;
 569    consts->MinPointSize = MIN_POINT_SIZE;
 570    consts->MaxPointSize = MAX_POINT_SIZE;
 571    consts->MinPointSizeAA = MIN_POINT_SIZE;
 572    consts->MaxPointSizeAA = MAX_POINT_SIZE;
 573    consts->PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
 574    consts->MinLineWidth = MIN_LINE_WIDTH;
 575    consts->MaxLineWidth = MAX_LINE_WIDTH;
 576    consts->MinLineWidthAA = MIN_LINE_WIDTH;
 577    consts->MaxLineWidthAA = MAX_LINE_WIDTH;
 578    consts->LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
 579    consts->MaxClipPlanes = 6;
 580    consts->MaxLights = MAX_LIGHTS;
 581    consts->MaxShininess = 128.0;
 582    consts->MaxSpotExponent = 128.0;
 583    consts->MaxViewportWidth = 16384;
 584    consts->MaxViewportHeight = 16384;
 585    consts->MinMapBufferAlignment = 64;
 586
 587    /* Driver must override these values if ARB_viewport_array is supported. */
 588    consts->MaxViewports = 1;
 589    consts->ViewportSubpixelBits = 0;
 590    consts->ViewportBounds.Min = 0;
 591    consts->ViewportBounds.Max = 0;
 592
 593    /** GL_ARB_uniform_buffer_object */
 594    consts->MaxCombinedUniformBlocks = 36;
 595    consts->MaxUniformBufferBindings = 36;
 596    consts->MaxUniformBlockSize = 16384;
 597    consts->UniformBufferOffsetAlignment = 1;
 598
 599    /** GL_ARB_shader_storage_buffer_object */
 600    consts->MaxCombinedShaderStorageBlocks = 8;
 601    consts->MaxShaderStorageBufferBindings = 8;
 602    consts->MaxShaderStorageBlockSize = 128 * 1024 * 1024; /* 2^27 */
 603    consts->ShaderStorageBufferOffsetAlignment = 256;
 604
 605    /* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */
 606    consts->MaxUserAssignableUniformLocations =
 607       4 * MESA_SHADER_STAGES * MAX_UNIFORMS;
 608
 609    for (i = 0; i < MESA_SHADER_STAGES; i++)
 610       init_program_limits(consts, i, &consts->Program[i]);
 611
 612    consts->MaxProgramMatrices = MAX_PROGRAM_MATRICES;
 613    consts->MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
 614
 615    /* Set the absolute minimum possible GLSL version.  API_OPENGL_CORE can
 616     * mean an OpenGL 3.0 forward-compatible context, so that implies a minimum
 617     * possible version of 1.30.  Otherwise, the minimum possible version 1.20.
 618     * Since Mesa unconditionally advertises GL_ARB_shading_language_100 and
 619     * GL_ARB_shader_objects, every driver has GLSL 1.20... even if they don't
 620     * advertise any extensions to enable any shader stages (e.g.,
 621     * GL_ARB_vertex_shader).
 622     */
 623    consts->GLSLVersion = api == API_OPENGL_CORE ? 130 : 120;
 624    consts->GLSLVersionCompat = consts->GLSLVersion;
 625
 626    consts->GLSLLowerConstArrays = true;
 627
 628    /* Assume that if GLSL 1.30+ (or GLSL ES 3.00+) is supported that
 629     * gl_VertexID is implemented using a native hardware register with OpenGL
 630     * semantics.
 631     */
 632    consts->VertexID_is_zero_based = false;
 633
 634    /* GL_ARB_draw_buffers */
 635    consts->MaxDrawBuffers = MAX_DRAW_BUFFERS;
 636
 637    consts->MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
 638    consts->MaxRenderbufferSize = MAX_RENDERBUFFER_SIZE;
 639
 640    consts->Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 641    consts->MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
 642    consts->MaxVarying = 16; /* old limit not to break tnl and swrast */
 643    consts->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 644    consts->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;
 645    consts->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;
 646    consts->MaxGeometryShaderInvocations = MAX_GEOMETRY_SHADER_INVOCATIONS;
 647
 648 #ifdef DEBUG
 649    consts->GenerateTemporaryNames = true;
 650 #else
 651    consts->GenerateTemporaryNames = false;
 652 #endif
 653
 654    /* GL_ARB_framebuffer_object */
 655    consts->MaxSamples = 0;
 656
 657    /* GLSL default if NativeIntegers == FALSE */
 658    consts->UniformBooleanTrue = FLOAT_AS_UNION(1.0f).u;
 659
 660    /* GL_ARB_sync */
 661    consts->MaxServerWaitTimeout = 0x7fffffff7fffffffULL;
 662
 663    /* GL_EXT_provoking_vertex */
 664    consts->QuadsFollowProvokingVertexConvention = GL_TRUE;
 665
 666    /** GL_ARB_viewport_array */
 667    consts->LayerAndVPIndexProvokingVertex = GL_UNDEFINED_VERTEX;
 668
 669    /* GL_EXT_transform_feedback */
 670    consts->MaxTransformFeedbackBuffers = MAX_FEEDBACK_BUFFERS;
 671    consts->MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;
 672    consts->MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;
 673    consts->MaxVertexStreams = 1;
 674
 675    /* GL 3.2  */
 676    consts->ProfileMask = api == API_OPENGL_CORE
 677                           ? GL_CONTEXT_CORE_PROFILE_BIT
 678                           : GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
 679
 680    /* GL 4.4 */
 681    consts->MaxVertexAttribStride = 2048;
 682
 683    /** GL_EXT_gpu_shader4 */
 684    consts->MinProgramTexelOffset = -8;
 685    consts->MaxProgramTexelOffset = 7;
 686
 687    /* GL_ARB_texture_gather */
 688    consts->MinProgramTextureGatherOffset = -8;
 689    consts->MaxProgramTextureGatherOffset = 7;
 690
 691    /* GL_ARB_robustness */
 692    consts->ResetStrategy = GL_NO_RESET_NOTIFICATION_ARB;
 693
 694    /* GL_KHR_robustness */
 695    consts->RobustAccess = GL_FALSE;
 696
 697    /* ES 3.0 or ARB_ES3_compatibility */
 698    consts->MaxElementIndex = 0xffffffffu;
 699
 700    /* GL_ARB_texture_multisample */
 701    consts->MaxColorTextureSamples = 1;
 702    consts->MaxDepthTextureSamples = 1;
 703    consts->MaxIntegerSamples = 1;
 704
 705    /* GL_ARB_shader_atomic_counters */
 706    consts->MaxAtomicBufferBindings = MAX_COMBINED_ATOMIC_BUFFERS;
 707    consts->MaxAtomicBufferSize = MAX_ATOMIC_COUNTERS * ATOMIC_COUNTER_SIZE;
 708    consts->MaxCombinedAtomicBuffers = MAX_COMBINED_ATOMIC_BUFFERS;
 709    consts->MaxCombinedAtomicCounters = MAX_ATOMIC_COUNTERS;
 710
 711    /* GL_ARB_vertex_attrib_binding */
 712    consts->MaxVertexAttribRelativeOffset = 2047;
 713    consts->MaxVertexAttribBindings = MAX_VERTEX_GENERIC_ATTRIBS;
 714
 715    /* GL_ARB_compute_shader */
 716    consts->MaxComputeWorkGroupCount[0] = 65535;
 717    consts->MaxComputeWorkGroupCount[1] = 65535;
 718    consts->MaxComputeWorkGroupCount[2] = 65535;
 719    consts->MaxComputeWorkGroupSize[0] = 1024;
 720    consts->MaxComputeWorkGroupSize[1] = 1024;
 721    consts->MaxComputeWorkGroupSize[2] = 64;
 722    /* Enables compute support for GLES 3.1 if >= 128 */
 723    consts->MaxComputeWorkGroupInvocations = 0;
 724
 725    /** GL_ARB_gpu_shader5 */
 726    consts->MinFragmentInterpolationOffset = MIN_FRAGMENT_INTERPOLATION_OFFSET;
 727    consts->MaxFragmentInterpolationOffset = MAX_FRAGMENT_INTERPOLATION_OFFSET;
 728
 729    /** GL_KHR_context_flush_control */
 730    consts->ContextReleaseBehavior = GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH;
 731
 732    /** GL_ARB_tessellation_shader */
 733    consts->MaxTessGenLevel = MAX_TESS_GEN_LEVEL;
 734    consts->MaxPatchVertices = MAX_PATCH_VERTICES;
 735    consts->Program[MESA_SHADER_TESS_CTRL].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 736    consts->Program[MESA_SHADER_TESS_EVAL].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 737    consts->MaxTessPatchComponents = MAX_TESS_PATCH_COMPONENTS;
 738    consts->MaxTessControlTotalOutputComponents = MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS;
 739    consts->PrimitiveRestartForPatches = false;
 740
 741    /** GL_ARB_compute_variable_group_size */
 742    consts->MaxComputeVariableGroupSize[0] = 512;
 743    consts->MaxComputeVariableGroupSize[1] = 512;
 744    consts->MaxComputeVariableGroupSize[2] = 64;
 745    consts->MaxComputeVariableGroupInvocations = 512;
 746
 747    /** GL_NV_conservative_raster */
 748    consts->MaxSubpixelPrecisionBiasBits = 0;
 749
 750    /** GL_NV_conservative_raster_dilate */
 751    consts->ConservativeRasterDilateRange[0] = 0.0;
 752    consts->ConservativeRasterDilateRange[1] = 0.0;
 753    consts->ConservativeRasterDilateGranularity = 0.0;
 754
 755    consts->glBeginEndBufferSize = 512 * 1024;
 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    _mesa_initialize();
1207
1208    /* Plug in driver functions and context pointer here.
1209     * This is important because when we call alloc_shared_state() below
1210     * we'll call ctx->Driver.NewTextureObject() to create the default
1211     * textures.
1212     */
1213    ctx->Driver = *driverFunctions;
1214
1215    if (share_list) {
1216       /* share state with another context */
1217       shared = share_list->Shared;
1218    }
1219    else {
1220       /* allocate new, unshared state */
1221       shared = _mesa_alloc_shared_state(ctx);
1222       if (!shared)
1223          return GL_FALSE;
1224    }
1225
1226    _mesa_reference_shared_state(ctx, &ctx->Shared, shared);
1227
1228    if (!init_attrib_groups( ctx ))
1229       goto fail;
1230
1231    /* KHR_no_error is likely to crash, overflow memory, etc if an application
1232     * has errors so don't enable it for setuid processes.
1233     */
1234    if (env_var_as_boolean("MESA_NO_ERROR", false)) {
1235 #if !defined(_WIN32)
1236       if (geteuid() == getuid())
1237 #endif
1238          ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR;
1239    }
1240
1241    /* setup the API dispatch tables with all nop functions */
1242    ctx->OutsideBeginEnd = _mesa_alloc_dispatch_table();
1243    if (!ctx->OutsideBeginEnd)
1244       goto fail;
1245    ctx->Exec = ctx->OutsideBeginEnd;
1246    ctx->CurrentClientDispatch = ctx->CurrentServerDispatch = ctx->OutsideBeginEnd;
1247
1248    ctx->FragmentProgram._MaintainTexEnvProgram
1249       = (getenv("MESA_TEX_PROG") != NULL);
1250
1251    ctx->VertexProgram._MaintainTnlProgram
1252       = (getenv("MESA_TNL_PROG") != NULL);
1253    if (ctx->VertexProgram._MaintainTnlProgram) {
1254       /* this is required... */
1255       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1256    }
1257
1258    /* Mesa core handles all the formats that mesa core knows about.
1259     * Drivers will want to override this list with just the formats
1260     * they can handle, and confirm that appropriate fallbacks exist in
1261     * _mesa_choose_tex_format().
1262     */
1263    memset(&ctx->TextureFormatSupported, GL_TRUE,
1264           sizeof(ctx->TextureFormatSupported));
1265
1266    switch (ctx->API) {
1267    case API_OPENGL_COMPAT:
1268       ctx->BeginEnd = create_beginend_table(ctx);
1269       ctx->Save = _mesa_alloc_dispatch_table();
1270       if (!ctx->BeginEnd || !ctx->Save)
1271          goto fail;
1272
1273       /* fall-through */
1274    case API_OPENGL_CORE:
1275       break;
1276    case API_OPENGLES:
1277       /**
1278        * GL_OES_texture_cube_map says
1279        * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
1280        */
1281       for (i = 0; i < ARRAY_SIZE(ctx->Texture.FixedFuncUnit); i++) {
1282          struct gl_fixedfunc_texture_unit *texUnit =
1283             &ctx->Texture.FixedFuncUnit[i];
1284
1285          texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
1286          texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
1287          texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
1288          texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1289          texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1290          texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1291       }
1292       break;
1293    case API_OPENGLES2:
1294       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1295       ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
1296       break;
1297    }
1298
1299    ctx->FirstTimeCurrent = GL_TRUE;
1300
1301    return GL_TRUE;
1302
1303 fail:
1304    _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1305    free(ctx->BeginEnd);
1306    free(ctx->OutsideBeginEnd);
1307    free(ctx->Save);
1308    return GL_FALSE;
1309 }
1310
1311
1312 /**
1313  * Free the data associated with the given context.
1314  *
1315  * But doesn't free the struct gl_context struct itself.
1316  *
1317  * \sa _mesa_initialize_context() and init_attrib_groups().
1318  */
1319 void
1320 _mesa_free_context_data(struct gl_context *ctx)
1321 {
1322    if (!_mesa_get_current_context()){
1323       /* No current context, but we may need one in order to delete
1324        * texture objs, etc.  So temporarily bind the context now.
1325        */
1326       _mesa_make_current(ctx, NULL, NULL);
1327    }
1328
1329    /* unreference WinSysDraw/Read buffers */
1330    _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
1331    _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
1332    _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
1333    _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
1334
1335    _mesa_reference_program(ctx, &ctx->VertexProgram.Current, NULL);
1336    _mesa_reference_program(ctx, &ctx->VertexProgram._Current, NULL);
1337    _mesa_reference_program(ctx, &ctx->VertexProgram._TnlProgram, NULL);
1338
1339    _mesa_reference_program(ctx, &ctx->TessCtrlProgram._Current, NULL);
1340    _mesa_reference_program(ctx, &ctx->TessEvalProgram._Current, NULL);
1341    _mesa_reference_program(ctx, &ctx->GeometryProgram._Current, NULL);
1342
1343    _mesa_reference_program(ctx, &ctx->FragmentProgram.Current, NULL);
1344    _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, NULL);
1345    _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
1346
1347    _mesa_reference_program(ctx, &ctx->ComputeProgram._Current, NULL);
1348
1349    _mesa_reference_vao(ctx, &ctx->Array.VAO, NULL);
1350    _mesa_reference_vao(ctx, &ctx->Array.DefaultVAO, NULL);
1351    _mesa_reference_vao(ctx, &ctx->Array._EmptyVAO, NULL);
1352    _mesa_reference_vao(ctx, &ctx->Array._DrawVAO, NULL);
1353
1354    _mesa_free_attrib_data(ctx);
1355    _mesa_free_buffer_objects(ctx);
1356    _mesa_free_eval_data( ctx );
1357    _mesa_free_texture_data( ctx );
1358    _mesa_free_image_textures(ctx);
1359    _mesa_free_matrix_data( ctx );
1360    _mesa_free_pipeline_data(ctx);
1361    _mesa_free_program_data(ctx);
1362    _mesa_free_shader_state(ctx);
1363    _mesa_free_queryobj_data(ctx);
1364    _mesa_free_sync_data(ctx);
1365    _mesa_free_varray_data(ctx);
1366    _mesa_free_transform_feedback(ctx);
1367    _mesa_free_performance_monitors(ctx);
1368    _mesa_free_performance_queries(ctx);
1369    _mesa_free_resident_handles(ctx);
1370
1371    _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
1372    _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
1373    _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
1374    _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
1375
1376    /* free dispatch tables */
1377    free(ctx->BeginEnd);
1378    free(ctx->OutsideBeginEnd);
1379    free(ctx->Save);
1380    free(ctx->ContextLost);
1381    free(ctx->MarshalExec);
1382
1383    /* Shared context state (display lists, textures, etc) */
1384    _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1385
1386    /* needs to be after freeing shared state */
1387    _mesa_free_display_list_data(ctx);
1388
1389    _mesa_free_errors_data(ctx);
1390
1391    free((void *)ctx->Extensions.String);
1392
1393    free(ctx->VersionString);
1394
1395    ralloc_free(ctx->SoftFP64);
1396
1397    /* unbind the context if it's currently bound */
1398    if (ctx == _mesa_get_current_context()) {
1399       _mesa_make_current(NULL, NULL, NULL);
1400    }
1401
1402    /* Do this after unbinding context to ensure any thread is finished. */
1403    if (ctx->shader_builtin_ref) {
1404       _mesa_glsl_builtin_functions_decref();
1405       ctx->shader_builtin_ref = false;
1406    }
1407
1408    free(ctx->Const.SpirVExtensions);
1409 }
1410
1411
1412 /**
1413  * Destroy a struct gl_context structure.
1414  *
1415  * \param ctx GL context.
1416  *
1417  * Calls _mesa_free_context_data() and frees the gl_context object itself.
1418  */
1419 void
1420 _mesa_destroy_context( struct gl_context *ctx )
1421 {
1422    if (ctx) {
1423       _mesa_free_context_data(ctx);
1424       free( (void *) ctx );
1425    }
1426 }
1427
1428
1429 /**
1430  * Copy attribute groups from one context to another.
1431  *
1432  * \param src source context
1433  * \param dst destination context
1434  * \param mask bitwise OR of GL_*_BIT flags
1435  *
1436  * According to the bits specified in \p mask, copies the corresponding
1437  * attributes from \p src into \p dst.  For many of the attributes a simple \c
1438  * memcpy is not enough due to the existence of internal pointers in their data
1439  * structures.
1440  */
1441 void
1442 _mesa_copy_context( const struct gl_context *src, struct gl_context *dst,
1443                     GLuint mask )
1444 {
1445    if (mask & GL_ACCUM_BUFFER_BIT) {
1446       /* OK to memcpy */
1447       dst->Accum = src->Accum;
1448    }
1449    if (mask & GL_COLOR_BUFFER_BIT) {
1450       /* OK to memcpy */
1451       dst->Color = src->Color;
1452    }
1453    if (mask & GL_CURRENT_BIT) {
1454       /* OK to memcpy */
1455       dst->Current = src->Current;
1456    }
1457    if (mask & GL_DEPTH_BUFFER_BIT) {
1458       /* OK to memcpy */
1459       dst->Depth = src->Depth;
1460    }
1461    if (mask & GL_ENABLE_BIT) {
1462       /* no op */
1463    }
1464    if (mask & GL_EVAL_BIT) {
1465       /* OK to memcpy */
1466       dst->Eval = src->Eval;
1467    }
1468    if (mask & GL_FOG_BIT) {
1469       /* OK to memcpy */
1470       dst->Fog = src->Fog;
1471    }
1472    if (mask & GL_HINT_BIT) {
1473       /* OK to memcpy */
1474       dst->Hint = src->Hint;
1475    }
1476    if (mask & GL_LIGHTING_BIT) {
1477       /* OK to memcpy */
1478       dst->Light = src->Light;
1479    }
1480    if (mask & GL_LINE_BIT) {
1481       /* OK to memcpy */
1482       dst->Line = src->Line;
1483    }
1484    if (mask & GL_LIST_BIT) {
1485       /* OK to memcpy */
1486       dst->List = src->List;
1487    }
1488    if (mask & GL_PIXEL_MODE_BIT) {
1489       /* OK to memcpy */
1490       dst->Pixel = src->Pixel;
1491    }
1492    if (mask & GL_POINT_BIT) {
1493       /* OK to memcpy */
1494       dst->Point = src->Point;
1495    }
1496    if (mask & GL_POLYGON_BIT) {
1497       /* OK to memcpy */
1498       dst->Polygon = src->Polygon;
1499    }
1500    if (mask & GL_POLYGON_STIPPLE_BIT) {
1501       /* Use loop instead of memcpy due to problem with Portland Group's
1502        * C compiler.  Reported by John Stone.
1503        */
1504       GLuint i;
1505       for (i = 0; i < 32; i++) {
1506          dst->PolygonStipple[i] = src->PolygonStipple[i];
1507       }
1508    }
1509    if (mask & GL_SCISSOR_BIT) {
1510       /* OK to memcpy */
1511       dst->Scissor = src->Scissor;
1512    }
1513    if (mask & GL_STENCIL_BUFFER_BIT) {
1514       /* OK to memcpy */
1515       dst->Stencil = src->Stencil;
1516    }
1517    if (mask & GL_TEXTURE_BIT) {
1518       /* Cannot memcpy because of pointers */
1519       _mesa_copy_texture_state(src, dst);
1520    }
1521    if (mask & GL_TRANSFORM_BIT) {
1522       /* OK to memcpy */
1523       dst->Transform = src->Transform;
1524    }
1525    if (mask & GL_VIEWPORT_BIT) {
1526       unsigned i;
1527       for (i = 0; i < src->Const.MaxViewports; i++) {
1528          /* OK to memcpy */
1529          dst->ViewportArray[i] = src->ViewportArray[i];
1530       }
1531    }
1532
1533    /* XXX FIXME:  Call callbacks?
1534     */
1535    dst->NewState = _NEW_ALL;
1536    dst->NewDriverState = ~0;
1537 }
1538
1539
1540 /**
1541  * Check if the given context can render into the given framebuffer
1542  * by checking visual attributes.
1543  *
1544  * \return GL_TRUE if compatible, GL_FALSE otherwise.
1545  */
1546 static GLboolean
1547 check_compatible(const struct gl_context *ctx,
1548                  const struct gl_framebuffer *buffer)
1549 {
1550    const struct gl_config *ctxvis = &ctx->Visual;
1551    const struct gl_config *bufvis = &buffer->Visual;
1552
1553    if (buffer == _mesa_get_incomplete_framebuffer())
1554       return GL_TRUE;
1555
1556 #define check_component(foo)           \
1557    if (ctxvis->foo && bufvis->foo &&   \
1558        ctxvis->foo != bufvis->foo)     \
1559       return GL_FALSE
1560
1561    check_component(redShift);
1562    check_component(greenShift);
1563    check_component(blueShift);
1564    check_component(redBits);
1565    check_component(greenBits);
1566    check_component(blueBits);
1567    check_component(depthBits);
1568    check_component(stencilBits);
1569
1570 #undef check_component
1571
1572    return GL_TRUE;
1573 }
1574
1575
1576 /**
1577  * Check if the viewport/scissor size has not yet been initialized.
1578  * Initialize the size if the given width and height are non-zero.
1579  */
1580 static void
1581 check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
1582 {
1583    if (!ctx->ViewportInitialized && width > 0 && height > 0) {
1584       unsigned i;
1585
1586       /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
1587        * potential infinite recursion.
1588        */
1589       ctx->ViewportInitialized = GL_TRUE;
1590
1591       /* Note: ctx->Const.MaxViewports may not have been set by the driver
1592        * yet, so just initialize all of them.
1593        */
1594       for (i = 0; i < MAX_VIEWPORTS; i++) {
1595          _mesa_set_viewport(ctx, i, 0, 0, width, height);
1596          _mesa_set_scissor(ctx, i, 0, 0, width, height);
1597       }
1598    }
1599 }
1600
1601
1602 static void
1603 handle_first_current(struct gl_context *ctx)
1604 {
1605    if (ctx->Version == 0 || !ctx->DrawBuffer) {
1606       /* probably in the process of tearing down the context */
1607       return;
1608    }
1609
1610    check_context_limits(ctx);
1611
1612    _mesa_update_vertex_processing_mode(ctx);
1613
1614    /* According to GL_MESA_configless_context the default value of
1615     * glDrawBuffers depends on the config of the first surface it is bound to.
1616     * For GLES it is always GL_BACK which has a magic interpretation.
1617     */
1618    if (!ctx->HasConfig && _mesa_is_desktop_gl(ctx)) {
1619       if (ctx->DrawBuffer != _mesa_get_incomplete_framebuffer()) {
1620          GLenum16 buffer;
1621
1622          if (ctx->DrawBuffer->Visual.doubleBufferMode)
1623             buffer = GL_BACK;
1624          else
1625             buffer = GL_FRONT;
1626
1627          _mesa_drawbuffers(ctx, ctx->DrawBuffer, 1, &buffer,
1628                            NULL /* destMask */);
1629       }
1630
1631       if (ctx->ReadBuffer != _mesa_get_incomplete_framebuffer()) {
1632          gl_buffer_index bufferIndex;
1633          GLenum buffer;
1634
1635          if (ctx->ReadBuffer->Visual.doubleBufferMode) {
1636             buffer = GL_BACK;
1637             bufferIndex = BUFFER_BACK_LEFT;
1638          }
1639          else {
1640             buffer = GL_FRONT;
1641             bufferIndex = BUFFER_FRONT_LEFT;
1642          }
1643
1644          _mesa_readbuffer(ctx, ctx->ReadBuffer, buffer, bufferIndex);
1645       }
1646    }
1647
1648    /* Determine if generic vertex attribute 0 aliases the conventional
1649     * glVertex position.
1650     */
1651    {
1652       const bool is_forward_compatible_context =
1653          ctx->Const.ContextFlags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT;
1654
1655       /* In OpenGL 3.1 attribute 0 becomes non-magic, just like in OpenGL ES
1656        * 2.0.  Note that we cannot just check for API_OPENGL_COMPAT here because
1657        * that will erroneously allow this usage in a 3.0 forward-compatible
1658        * context too.
1659        */
1660       ctx->_AttribZeroAliasesVertex = (ctx->API == API_OPENGLES
1661                                        || (ctx->API == API_OPENGL_COMPAT
1662                                            && !is_forward_compatible_context));
1663    }
1664
1665    /* We can use this to help debug user's problems.  Tell them to set
1666     * the MESA_INFO env variable before running their app.  Then the
1667     * first time each context is made current we'll print some useful
1668     * information.
1669     */
1670    if (getenv("MESA_INFO")) {
1671       _mesa_print_info(ctx);
1672    }
1673 }
1674
1675 /**
1676  * Bind the given context to the given drawBuffer and readBuffer and
1677  * make it the current context for the calling thread.
1678  * We'll render into the drawBuffer and read pixels from the
1679  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1680  *
1681  * We check that the context's and framebuffer's visuals are compatible
1682  * and return immediately if they're not.
1683  *
1684  * \param newCtx  the new GL context. If NULL then there will be no current GL
1685  *                context.
1686  * \param drawBuffer  the drawing framebuffer
1687  * \param readBuffer  the reading framebuffer
1688  */
1689 GLboolean
1690 _mesa_make_current( struct gl_context *newCtx,
1691                     struct gl_framebuffer *drawBuffer,
1692                     struct gl_framebuffer *readBuffer )
1693 {
1694    GET_CURRENT_CONTEXT(curCtx);
1695
1696    if (MESA_VERBOSE & VERBOSE_API)
1697       _mesa_debug(newCtx, "_mesa_make_current()\n");
1698
1699    /* Check that the context's and framebuffer's visuals are compatible.
1700     */
1701    if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1702       if (!check_compatible(newCtx, drawBuffer)) {
1703          _mesa_warning(newCtx,
1704               "MakeCurrent: incompatible visuals for context and drawbuffer");
1705          return GL_FALSE;
1706       }
1707    }
1708    if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1709       if (!check_compatible(newCtx, readBuffer)) {
1710          _mesa_warning(newCtx,
1711               "MakeCurrent: incompatible visuals for context and readbuffer");
1712          return GL_FALSE;
1713       }
1714    }
1715
1716    if (curCtx &&
1717        (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) &&
1718        /* make sure this context is valid for flushing */
1719        curCtx != newCtx &&
1720        curCtx->Const.ContextReleaseBehavior ==
1721        GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH) {
1722       _mesa_flush(curCtx);
1723    }
1724
1725    /* Call this periodically to detect when the user has begun using
1726     * GL rendering from multiple threads.
1727     */
1728    _glapi_check_multithread();
1729
1730    if (!newCtx) {
1731       _glapi_set_dispatch(NULL);  /* none current */
1732       /* We need old ctx to correctly release Draw/ReadBuffer
1733        * and avoid a surface leak in st_renderbuffer_delete.
1734        * Therefore, first drop buffers then set new ctx to NULL.
1735        */
1736       if (curCtx) {
1737          _mesa_reference_framebuffer(&curCtx->WinSysDrawBuffer, NULL);
1738          _mesa_reference_framebuffer(&curCtx->WinSysReadBuffer, NULL);
1739       }
1740       _glapi_set_context(NULL);
1741       assert(_mesa_get_current_context() == NULL);
1742    }
1743    else {
1744       _glapi_set_context((void *) newCtx);
1745       assert(_mesa_get_current_context() == newCtx);
1746       _glapi_set_dispatch(newCtx->CurrentClientDispatch);
1747
1748       if (drawBuffer && readBuffer) {
1749          assert(_mesa_is_winsys_fbo(drawBuffer));
1750          assert(_mesa_is_winsys_fbo(readBuffer));
1751          _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1752          _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1753
1754          /*
1755           * Only set the context's Draw/ReadBuffer fields if they're NULL
1756           * or not bound to a user-created FBO.
1757           */
1758          if (!newCtx->DrawBuffer || _mesa_is_winsys_fbo(newCtx->DrawBuffer)) {
1759             _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1760             /* Update the FBO's list of drawbuffers/renderbuffers.
1761              * For winsys FBOs this comes from the GL state (which may have
1762              * changed since the last time this FBO was bound).
1763              */
1764             _mesa_update_draw_buffers(newCtx);
1765             _mesa_update_allow_draw_out_of_order(newCtx);
1766          }
1767          if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) {
1768             _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1769             /* In _mesa_initialize_window_framebuffer, for single-buffered
1770              * visuals, the ColorReadBuffer is set to be GL_FRONT, even with
1771              * GLES contexts. When calling read_buffer, we verify we are reading
1772              * from GL_BACK in is_legal_es3_readbuffer_enum.  But the default is
1773              * incorrect, and certain dEQP tests check this.  So fix it here.
1774              */
1775             if (_mesa_is_gles(newCtx) &&
1776                !newCtx->ReadBuffer->Visual.doubleBufferMode)
1777                if (newCtx->ReadBuffer->ColorReadBuffer == GL_FRONT)
1778                   newCtx->ReadBuffer->ColorReadBuffer = GL_BACK;
1779          }
1780
1781          /* XXX only set this flag if we're really changing the draw/read
1782           * framebuffer bindings.
1783           */
1784          newCtx->NewState |= _NEW_BUFFERS;
1785
1786          check_init_viewport(newCtx, drawBuffer->Width, drawBuffer->Height);
1787       }
1788
1789       if (newCtx->FirstTimeCurrent) {
1790          handle_first_current(newCtx);
1791          newCtx->FirstTimeCurrent = GL_FALSE;
1792       }
1793    }
1794
1795    return GL_TRUE;
1796 }
1797
1798
1799 /**
1800  * Make context 'ctx' share the display lists, textures and programs
1801  * that are associated with 'ctxToShare'.
1802  * Any display lists, textures or programs associated with 'ctx' will
1803  * be deleted if nobody else is sharing them.
1804  */
1805 GLboolean
1806 _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
1807 {
1808    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1809       struct gl_shared_state *oldShared = NULL;
1810
1811       /* save ref to old state to prevent it from being deleted immediately */
1812       _mesa_reference_shared_state(ctx, &oldShared, ctx->Shared);
1813
1814       /* update ctx's Shared pointer */
1815       _mesa_reference_shared_state(ctx, &ctx->Shared, ctxToShare->Shared);
1816
1817       update_default_objects(ctx);
1818
1819       /* release the old shared state */
1820       _mesa_reference_shared_state(ctx, &oldShared, NULL);
1821
1822       return GL_TRUE;
1823    }
1824    else {
1825       return GL_FALSE;
1826    }
1827 }
1828
1829
1830
1831 /**
1832  * \return pointer to the current GL context for this thread.
1833  *
1834  * Calls _glapi_get_context(). This isn't the fastest way to get the current
1835  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
1836  * context.h.
1837  */
1838 struct gl_context *
1839 _mesa_get_current_context( void )
1840 {
1841    return (struct gl_context *) _glapi_get_context();
1842 }
1843
1844
1845 /**
1846  * Get context's current API dispatch table.
1847  *
1848  * It'll either be the immediate-mode execute dispatcher, the display list
1849  * compile dispatcher, or the thread marshalling dispatcher.
1850  *
1851  * \param ctx GL context.
1852  *
1853  * \return pointer to dispatch_table.
1854  *
1855  * Simply returns __struct gl_contextRec::CurrentClientDispatch.
1856  */
1857 struct _glapi_table *
1858 _mesa_get_dispatch(struct gl_context *ctx)
1859 {
1860    return ctx->CurrentClientDispatch;
1861 }
1862
1863 /*@}*/
1864
1865
1866 /**********************************************************************/
1867 /** \name Miscellaneous functions                                     */
1868 /**********************************************************************/
1869 /*@{*/
1870 /**
1871  * Flush commands.
1872  */
1873 void
1874 _mesa_flush(struct gl_context *ctx)
1875 {
1876    FLUSH_VERTICES( ctx, 0 );
1877    if (ctx->Driver.Flush) {
1878       ctx->Driver.Flush(ctx);
1879    }
1880 }
1881
1882
1883
1884 /**
1885  * Flush commands and wait for completion.
1886  *
1887  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1888  * dd_function_table::Finish driver callback, if not NULL.
1889  */
1890 void GLAPIENTRY
1891 _mesa_Finish(void)
1892 {
1893    GET_CURRENT_CONTEXT(ctx);
1894    ASSERT_OUTSIDE_BEGIN_END(ctx);
1895
1896    FLUSH_VERTICES(ctx, 0);
1897
1898    if (ctx->Driver.Finish) {
1899       ctx->Driver.Finish(ctx);
1900    }
1901 }
1902
1903
1904 /**
1905  * Execute glFlush().
1906  *
1907  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1908  * dd_function_table::Flush driver callback, if not NULL.
1909  */
1910 void GLAPIENTRY
1911 _mesa_Flush(void)
1912 {
1913    GET_CURRENT_CONTEXT(ctx);
1914    ASSERT_OUTSIDE_BEGIN_END(ctx);
1915    _mesa_flush(ctx);
1916 }
1917
1918
1919 /*@}*/