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