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