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