src/mesa/main/context.c

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