src/mesa/main/context.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.3
   4  *
   5  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   6  * Copyright (C) 2008  VMware, Inc.  All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR 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 "mfeatures.h"
  81 #include "imports.h"
  82 #include "accum.h"
  83 #include "api_exec.h"
  84 #include "arrayobj.h"
  85 #include "attrib.h"
  86 #include "blend.h"
  87 #include "buffers.h"
  88 #include "bufferobj.h"
  89 #include "colortab.h"
  90 #include "context.h"
  91 #include "cpuinfo.h"
  92 #include "debug.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 "framebuffer.h"
 101 #include "histogram.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 "pixel.h"
 110 #include "pixelstore.h"
 111 #include "points.h"
 112 #include "polygon.h"
 113 #include "queryobj.h"
 114 #if FEATURE_ARB_sync
 115 #include "syncobj.h"
 116 #endif
 117 #include "rastpos.h"
 118 #include "remap.h"
 119 #include "scissor.h"
 120 #include "shared.h"
 121 #include "simple_list.h"
 122 #include "state.h"
 123 #include "stencil.h"
 124 #include "texcompress_s3tc.h"
 125 #include "texstate.h"
 126 #include "transformfeedback.h"
 127 #include "mtypes.h"
 128 #include "varray.h"
 129 #include "version.h"
 130 #include "viewport.h"
 131 #include "vtxfmt.h"
 132 #include "shader/program.h"
 133 #include "shader/prog_print.h"
 134 #include "shader/shader_api.h"
 135 #if _HAVE_FULL_GL
 136 #include "math/m_matrix.h"
 137 #endif
 138
 139 #ifdef USE_SPARC_ASM
 140 #include "sparc/sparc.h"
 141 #endif
 142
 143 #ifndef MESA_VERBOSE
 144 int MESA_VERBOSE = 0;
 145 #endif
 146
 147 #ifndef MESA_DEBUG_FLAGS
 148 int MESA_DEBUG_FLAGS = 0;
 149 #endif
 150
 151
 152 /* ubyte -> float conversion */
 153 GLfloat _mesa_ubyte_to_float_color_tab[256];
 154
 155
 156
 157 /**
 158  * Swap buffers notification callback.
 159  *
 160  * \param ctx GL context.
 161  *
 162  * Called by window system just before swapping buffers.
 163  * We have to finish any pending rendering.
 164  */
 165 void
 166 _mesa_notifySwapBuffers(__GLcontext *ctx)
 167 {
 168    if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)
 169       _mesa_debug(ctx, "SwapBuffers\n");
 170    FLUSH_CURRENT( ctx, 0 );
 171    if (ctx->Driver.Flush) {
 172       ctx->Driver.Flush(ctx);
 173    }
 174 }
 175
 176
 177 /**********************************************************************/
 178 /** \name GL Visual allocation/destruction                            */
 179 /**********************************************************************/
 180 /*@{*/
 181
 182 /**
 183  * Allocates a GLvisual structure and initializes it via
 184  * _mesa_initialize_visual().
 185  *
 186  * \param dbFlag double buffering
 187  * \param stereoFlag stereo buffer
 188  * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
 189  * is acceptable but the actual depth type will be GLushort or GLuint as
 190  * needed.
 191  * \param stencilBits requested minimum bits per stencil buffer value
 192  * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.
 193  * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
 194  * \param redBits number of bits per color component in frame buffer for RGB(A)
 195  * mode.  We always use 8 in core Mesa though.
 196  * \param greenBits same as above.
 197  * \param blueBits same as above.
 198  * \param alphaBits same as above.
 199  * \param numSamples not really used.
 200  *
 201  * \return pointer to new GLvisual or NULL if requested parameters can't be
 202  * met.
 203  *
 204  * \note Need to add params for level and numAuxBuffers (at least)
 205  */
 206 GLvisual *
 207 _mesa_create_visual( GLboolean dbFlag,
 208                      GLboolean stereoFlag,
 209                      GLint redBits,
 210                      GLint greenBits,
 211                      GLint blueBits,
 212                      GLint alphaBits,
 213                      GLint depthBits,
 214                      GLint stencilBits,
 215                      GLint accumRedBits,
 216                      GLint accumGreenBits,
 217                      GLint accumBlueBits,
 218                      GLint accumAlphaBits,
 219                      GLint numSamples )
 220 {
 221    GLvisual *vis = (GLvisual *) calloc(1, sizeof(GLvisual));
 222    if (vis) {
 223       if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,
 224                                    redBits, greenBits, blueBits, alphaBits,
 225                                    depthBits, stencilBits,
 226                                    accumRedBits, accumGreenBits,
 227                                    accumBlueBits, accumAlphaBits,
 228                                    numSamples)) {
 229          free(vis);
 230          return NULL;
 231       }
 232    }
 233    return vis;
 234 }
 235
 236 /**
 237  * Makes some sanity checks and fills in the fields of the
 238  * GLvisual object with the given parameters.  If the caller needs
 239  * to set additional fields, he should just probably init the whole GLvisual
 240  * object himself.
 241  * \return GL_TRUE on success, or GL_FALSE on failure.
 242  *
 243  * \sa _mesa_create_visual() above for the parameter description.
 244  */
 245 GLboolean
 246 _mesa_initialize_visual( GLvisual *vis,
 247                          GLboolean dbFlag,
 248                          GLboolean stereoFlag,
 249                          GLint redBits,
 250                          GLint greenBits,
 251                          GLint blueBits,
 252                          GLint alphaBits,
 253                          GLint depthBits,
 254                          GLint stencilBits,
 255                          GLint accumRedBits,
 256                          GLint accumGreenBits,
 257                          GLint accumBlueBits,
 258                          GLint accumAlphaBits,
 259                          GLint numSamples )
 260 {
 261    assert(vis);
 262
 263    if (depthBits < 0 || depthBits > 32) {
 264       return GL_FALSE;
 265    }
 266    if (stencilBits < 0 || stencilBits > STENCIL_BITS) {
 267       return GL_FALSE;
 268    }
 269    assert(accumRedBits >= 0);
 270    assert(accumGreenBits >= 0);
 271    assert(accumBlueBits >= 0);
 272    assert(accumAlphaBits >= 0);
 273
 274    vis->rgbMode          = GL_TRUE;
 275    vis->doubleBufferMode = dbFlag;
 276    vis->stereoMode       = stereoFlag;
 277
 278    vis->redBits          = redBits;
 279    vis->greenBits        = greenBits;
 280    vis->blueBits         = blueBits;
 281    vis->alphaBits        = alphaBits;
 282    vis->rgbBits          = redBits + greenBits + blueBits;
 283
 284    vis->indexBits      = 0;
 285    vis->depthBits      = depthBits;
 286    vis->stencilBits    = stencilBits;
 287
 288    vis->accumRedBits   = accumRedBits;
 289    vis->accumGreenBits = accumGreenBits;
 290    vis->accumBlueBits  = accumBlueBits;
 291    vis->accumAlphaBits = accumAlphaBits;
 292
 293    vis->haveAccumBuffer   = accumRedBits > 0;
 294    vis->haveDepthBuffer   = depthBits > 0;
 295    vis->haveStencilBuffer = stencilBits > 0;
 296
 297    vis->numAuxBuffers = 0;
 298    vis->level = 0;
 299    vis->pixmapMode = 0;
 300    vis->sampleBuffers = numSamples > 0 ? 1 : 0;
 301    vis->samples = numSamples;
 302
 303    return GL_TRUE;
 304 }
 305
 306
 307 /**
 308  * Destroy a visual and free its memory.
 309  *
 310  * \param vis visual.
 311  *
 312  * Frees the visual structure.
 313  */
 314 void
 315 _mesa_destroy_visual( GLvisual *vis )
 316 {
 317    free(vis);
 318 }
 319
 320 /*@}*/
 321
 322
 323 /**********************************************************************/
 324 /** \name Context allocation, initialization, destroying
 325  *
 326  * The purpose of the most initialization functions here is to provide the
 327  * default state values according to the OpenGL specification.
 328  */
 329 /**********************************************************************/
 330 /*@{*/
 331
 332
 333 /**
 334  * This is lame.  gdb only seems to recognize enum types that are
 335  * actually used somewhere.  We want to be able to print/use enum
 336  * values such as TEXTURE_2D_INDEX in gdb.  But we don't actually use
 337  * the gl_texture_index type anywhere.  Thus, this lame function.
 338  */
 339 static void
 340 dummy_enum_func(void)
 341 {
 342    gl_buffer_index bi;
 343    gl_colortable_index ci;
 344    gl_face_index fi;
 345    gl_frag_attrib fa;
 346    gl_frag_result fr;
 347    gl_texture_index ti;
 348    gl_vert_attrib va;
 349    gl_vert_result vr;
 350
 351    (void) bi;
 352    (void) ci;
 353    (void) fi;
 354    (void) fa;
 355    (void) fr;
 356    (void) ti;
 357    (void) va;
 358    (void) vr;
 359 }
 360
 361
 362 /**
 363  * One-time initialization mutex lock.
 364  *
 365  * \sa Used by one_time_init().
 366  */
 367 _glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
 368
 369 /**
 370  * Calls all the various one-time-init functions in Mesa.
 371  *
 372  * While holding a global mutex lock, calls several initialization functions,
 373  * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
 374  * defined.
 375  *
 376  * \sa _math_init().
 377  */
 378 static void
 379 one_time_init( GLcontext *ctx )
 380 {
 381    static GLboolean alreadyCalled = GL_FALSE;
 382    (void) ctx;
 383    _glthread_LOCK_MUTEX(OneTimeLock);
 384    if (!alreadyCalled) {
 385       GLuint i;
 386
 387       /* do some implementation tests */
 388       assert( sizeof(GLbyte) == 1 );
 389       assert( sizeof(GLubyte) == 1 );
 390       assert( sizeof(GLshort) == 2 );
 391       assert( sizeof(GLushort) == 2 );
 392       assert( sizeof(GLint) == 4 );
 393       assert( sizeof(GLuint) == 4 );
 394
 395       _mesa_get_cpu_features();
 396
 397       switch (ctx->API) {
 398 #if FEATURE_GL
 399       case API_OPENGL:
 400          _mesa_init_remap_table();
 401          break;
 402 #endif
 403 #if FEATURE_ES1
 404       case API_OPENGLES:
 405          _mesa_init_remap_table_es1();
 406          break;
 407 #endif
 408 #if FEATURE_ES2
 409       case API_OPENGLES2:
 410          _mesa_init_remap_table_es2();
 411          break;
 412 #endif
 413       default:
 414          break;
 415       }
 416
 417       _mesa_init_sqrt_table();
 418
 419       for (i = 0; i < 256; i++) {
 420          _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
 421       }
 422
 423 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
 424       _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
 425                   MESA_VERSION_STRING, __DATE__, __TIME__);
 426 #endif
 427
 428       alreadyCalled = GL_TRUE;
 429    }
 430    _glthread_UNLOCK_MUTEX(OneTimeLock);
 431
 432    dummy_enum_func();
 433 }
 434
 435
 436 /**
 437  * Initialize fields of gl_current_attrib (aka ctx->Current.*)
 438  */
 439 static void
 440 _mesa_init_current(GLcontext *ctx)
 441 {
 442    GLuint i;
 443
 444    /* Init all to (0,0,0,1) */
 445    for (i = 0; i < Elements(ctx->Current.Attrib); i++) {
 446       ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
 447    }
 448
 449    /* redo special cases: */
 450    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );
 451    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
 452    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
 453    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
 454    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
 455    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
 456 }
 457
 458
 459 /**
 460  * Init vertex/fragment program limits.
 461  * Important: drivers should override these with actual limits.
 462  */
 463 static void
 464 init_program_limits(GLenum type, struct gl_program_constants *prog)
 465 {
 466    prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
 467    prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
 468    prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
 469    prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
 470    prog->MaxTemps = MAX_PROGRAM_TEMPS;
 471    prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
 472    prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
 473    prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 474
 475    if (type == GL_VERTEX_PROGRAM_ARB) {
 476       prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
 477       prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
 478       prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
 479    }
 480    else {
 481       prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
 482       prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
 483       prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
 484    }
 485
 486    /* Set the native limits to zero.  This implies that there is no native
 487     * support for shaders.  Let the drivers fill in the actual values.
 488     */
 489    prog->MaxNativeInstructions = 0;
 490    prog->MaxNativeAluInstructions = 0;
 491    prog->MaxNativeTexInstructions = 0;
 492    prog->MaxNativeTexIndirections = 0;
 493    prog->MaxNativeAttribs = 0;
 494    prog->MaxNativeTemps = 0;
 495    prog->MaxNativeAddressRegs = 0;
 496    prog->MaxNativeParameters = 0;
 497 }
 498
 499
 500 /**
 501  * Initialize fields of gl_constants (aka ctx->Const.*).
 502  * Use defaults from config.h.  The device drivers will often override
 503  * some of these values (such as number of texture units).
 504  */
 505 static void
 506 _mesa_init_constants(GLcontext *ctx)
 507 {
 508    assert(ctx);
 509
 510    /* Constants, may be overriden (usually only reduced) by device drivers */
 511    ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
 512    ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
 513    ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
 514    ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
 515    ctx->Const.MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
 516    ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
 517    ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 518    ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,
 519                                      ctx->Const.MaxTextureImageUnits);
 520    ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
 521    ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
 522    ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
 523    ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
 524    ctx->Const.MinPointSize = MIN_POINT_SIZE;
 525    ctx->Const.MaxPointSize = MAX_POINT_SIZE;
 526    ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
 527    ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
 528    ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
 529    ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
 530    ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
 531    ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
 532    ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
 533    ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
 534    ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
 535    ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
 536    ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
 537    ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
 538    ctx->Const.MaxLights = MAX_LIGHTS;
 539    ctx->Const.MaxShininess = 128.0;
 540    ctx->Const.MaxSpotExponent = 128.0;
 541    ctx->Const.MaxViewportWidth = MAX_WIDTH;
 542    ctx->Const.MaxViewportHeight = MAX_HEIGHT;
 543 #if FEATURE_ARB_vertex_program
 544    init_program_limits(GL_VERTEX_PROGRAM_ARB, &ctx->Const.VertexProgram);
 545 #endif
 546 #if FEATURE_ARB_fragment_program
 547    init_program_limits(GL_FRAGMENT_PROGRAM_ARB, &ctx->Const.FragmentProgram);
 548 #endif
 549    ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
 550    ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
 551
 552    /* CheckArrayBounds is overriden by drivers/x11 for X server */
 553    ctx->Const.CheckArrayBounds = GL_FALSE;
 554
 555    /* GL_ARB_draw_buffers */
 556    ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
 557
 558 #if FEATURE_EXT_framebuffer_object
 559    ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
 560    ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
 561 #endif
 562
 563 #if FEATURE_ARB_vertex_shader
 564    ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
 565    ctx->Const.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
 566    ctx->Const.MaxVarying = MAX_VARYING;
 567 #endif
 568
 569    /* GL_ARB_framebuffer_object */
 570    ctx->Const.MaxSamples = 0;
 571
 572    /* GL_ARB_sync */
 573    ctx->Const.MaxServerWaitTimeout = (GLuint64) ~0;
 574
 575    /* GL_ATI_envmap_bumpmap */
 576    ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS;
 577
 578    /* GL_EXT_provoking_vertex */
 579    ctx->Const.QuadsFollowProvokingVertexConvention = GL_TRUE;
 580
 581    /* GL_EXT_transform_feedback */
 582    ctx->Const.MaxTransformFeedbackSeparateAttribs = MAX_FEEDBACK_ATTRIBS;
 583    ctx->Const.MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;
 584    ctx->Const.MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;
 585
 586    /* GL 3.2: hard-coded for now: */
 587    ctx->Const.ProfileMask = GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
 588 }
 589
 590
 591 /**
 592  * Do some sanity checks on the limits/constants for the given context.
 593  * Only called the first time a context is bound.
 594  */
 595 static void
 596 check_context_limits(GLcontext *ctx)
 597 {
 598    /* check that we don't exceed the size of various bitfields */
 599    assert(VERT_RESULT_MAX <=
 600           (8 * sizeof(ctx->VertexProgram._Current->Base.OutputsWritten)));
 601    assert(FRAG_ATTRIB_MAX <=
 602           (8 * sizeof(ctx->FragmentProgram._Current->Base.InputsRead)));
 603
 604    assert(MAX_COMBINED_TEXTURE_IMAGE_UNITS <= 8 * sizeof(GLbitfield));
 605
 606    /* shader-related checks */
 607    assert(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
 608    assert(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
 609
 610    assert(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
 611    assert(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
 612    assert(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);
 613    assert(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);
 614
 615    /* Texture unit checks */
 616    assert(ctx->Const.MaxTextureImageUnits > 0);
 617    assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
 618    assert(ctx->Const.MaxTextureCoordUnits > 0);
 619    assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
 620    assert(ctx->Const.MaxTextureUnits > 0);
 621    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
 622    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
 623    assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,
 624                                              ctx->Const.MaxTextureCoordUnits));
 625    assert(ctx->Const.MaxCombinedTextureImageUnits > 0);
 626    assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
 627    assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
 628    /* number of coord units cannot be greater than number of image units */
 629    assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits);
 630
 631
 632    /* Texture size checks */
 633    assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
 634    assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
 635    assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
 636    assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
 637
 638    /* make sure largest texture image is <= MAX_WIDTH in size */
 639    assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= MAX_WIDTH);
 640    assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= MAX_WIDTH);
 641    assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= MAX_WIDTH);
 642
 643    /* Texture level checks */
 644    assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
 645    assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
 646
 647    /* Max texture size should be <= max viewport size (render to texture) */
 648    assert((1 << (MAX_TEXTURE_LEVELS - 1)) <= MAX_WIDTH);
 649
 650    assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);
 651    assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);
 652
 653    assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
 654
 655    /* XXX probably add more tests */
 656 }
 657
 658
 659 /**
 660  * Initialize the attribute groups in a GL context.
 661  *
 662  * \param ctx GL context.
 663  *
 664  * Initializes all the attributes, calling the respective <tt>init*</tt>
 665  * functions for the more complex data structures.
 666  */
 667 static GLboolean
 668 init_attrib_groups(GLcontext *ctx)
 669 {
 670    assert(ctx);
 671
 672    /* Constants */
 673    _mesa_init_constants( ctx );
 674
 675    /* Extensions */
 676    _mesa_init_extensions( ctx );
 677
 678    /* Attribute Groups */
 679    _mesa_init_accum( ctx );
 680    _mesa_init_attrib( ctx );
 681    _mesa_init_buffer_objects( ctx );
 682    _mesa_init_color( ctx );
 683    _mesa_init_colortables( ctx );
 684    _mesa_init_current( ctx );
 685    _mesa_init_depth( ctx );
 686    _mesa_init_debug( ctx );
 687    _mesa_init_display_list( ctx );
 688    _mesa_init_eval( ctx );
 689    _mesa_init_fbobjects( ctx );
 690    _mesa_init_feedback( ctx );
 691    _mesa_init_fog( ctx );
 692    _mesa_init_histogram( ctx );
 693    _mesa_init_hint( ctx );
 694    _mesa_init_line( ctx );
 695    _mesa_init_lighting( ctx );
 696    _mesa_init_matrix( ctx );
 697    _mesa_init_multisample( ctx );
 698    _mesa_init_pixel( ctx );
 699    _mesa_init_pixelstore( ctx );
 700    _mesa_init_point( ctx );
 701    _mesa_init_polygon( ctx );
 702    _mesa_init_program( ctx );
 703    _mesa_init_queryobj( ctx );
 704 #if FEATURE_ARB_sync
 705    _mesa_init_sync( ctx );
 706 #endif
 707    _mesa_init_rastpos( ctx );
 708    _mesa_init_scissor( ctx );
 709    _mesa_init_shader_state( ctx );
 710    _mesa_init_stencil( ctx );
 711    _mesa_init_transform( ctx );
 712    _mesa_init_transform_feedback( ctx );
 713    _mesa_init_varray( ctx );
 714    _mesa_init_viewport( ctx );
 715
 716    if (!_mesa_init_texture( ctx ))
 717       return GL_FALSE;
 718
 719    _mesa_init_texture_s3tc( ctx );
 720
 721    /* Miscellaneous */
 722    ctx->NewState = _NEW_ALL;
 723    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
 724    ctx->varying_vp_inputs = ~0;
 725
 726    return GL_TRUE;
 727 }
 728
 729
 730 /**
 731  * Update default objects in a GL context with respect to shared state.
 732  *
 733  * \param ctx GL context.
 734  *
 735  * Removes references to old default objects, (texture objects, program
 736  * objects, etc.) and changes to reference those from the current shared
 737  * state.
 738  */
 739 static GLboolean
 740 update_default_objects(GLcontext *ctx)
 741 {
 742    assert(ctx);
 743
 744    _mesa_update_default_objects_program(ctx);
 745    _mesa_update_default_objects_texture(ctx);
 746    _mesa_update_default_objects_buffer_objects(ctx);
 747
 748    return GL_TRUE;
 749 }
 750
 751
 752 /**
 753  * This is the default function we plug into all dispatch table slots
 754  * This helps prevents a segfault when someone calls a GL function without
 755  * first checking if the extension's supported.
 756  */
 757 static int
 758 generic_nop(void)
 759 {
 760    _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)");
 761    return 0;
 762 }
 763
 764
 765 /**
 766  * Allocate and initialize a new dispatch table.
 767  */
 768 struct _glapi_table *
 769 _mesa_alloc_dispatch_table(int size)
 770 {
 771    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
 772     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
 773     * Mesa we do this to accomodate different versions of libGL and various
 774     * DRI drivers.
 775     */
 776    GLint numEntries = MAX2(_glapi_get_dispatch_table_size(),
 777                            size / sizeof(_glapi_proc));
 778    struct _glapi_table *table =
 779       (struct _glapi_table *) malloc(numEntries * sizeof(_glapi_proc));
 780    if (table) {
 781       _glapi_proc *entry = (_glapi_proc *) table;
 782       GLint i;
 783       for (i = 0; i < numEntries; i++) {
 784          entry[i] = (_glapi_proc) generic_nop;
 785       }
 786    }
 787    return table;
 788 }
 789
 790
 791 /**
 792  * Initialize a GLcontext struct (rendering context).
 793  *
 794  * This includes allocating all the other structs and arrays which hang off of
 795  * the context by pointers.
 796  * Note that the driver needs to pass in its dd_function_table here since
 797  * we need to at least call driverFunctions->NewTextureObject to create the
 798  * default texture objects.
 799  *
 800  * Called by _mesa_create_context().
 801  *
 802  * Performs the imports and exports callback tables initialization, and
 803  * miscellaneous one-time initializations. If no shared context is supplied one
 804  * is allocated, and increase its reference count.  Setups the GL API dispatch
 805  * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
 806  * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
 807  * for debug flags.
 808  *
 809  * \param ctx the context to initialize
 810  * \param api the GL API type to create the context for
 811  * \param visual describes the visual attributes for this context
 812  * \param share_list points to context to share textures, display lists,
 813  *        etc with, or NULL
 814  * \param driverFunctions table of device driver functions for this context
 815  *        to use
 816  * \param driverContext pointer to driver-specific context data
 817  */
 818 GLboolean
 819 _mesa_initialize_context_for_api(GLcontext *ctx,
 820                                  gl_api api,
 821                                  const GLvisual *visual,
 822                                  GLcontext *share_list,
 823                                  const struct dd_function_table *driverFunctions,
 824                                  void *driverContext)
 825 {
 826    struct gl_shared_state *shared;
 827    int i;
 828
 829    /*ASSERT(driverContext);*/
 830    assert(driverFunctions->NewTextureObject);
 831    assert(driverFunctions->FreeTexImageData);
 832
 833    ctx->API = api;
 834    ctx->Visual = *visual;
 835    ctx->DrawBuffer = NULL;
 836    ctx->ReadBuffer = NULL;
 837    ctx->WinSysDrawBuffer = NULL;
 838    ctx->WinSysReadBuffer = NULL;
 839
 840    /* misc one-time initializations */
 841    one_time_init(ctx);
 842
 843    /* Plug in driver functions and context pointer here.
 844     * This is important because when we call alloc_shared_state() below
 845     * we'll call ctx->Driver.NewTextureObject() to create the default
 846     * textures.
 847     */
 848    ctx->Driver = *driverFunctions;
 849    ctx->DriverCtx = driverContext;
 850
 851    if (share_list) {
 852       /* share state with another context */
 853       shared = share_list->Shared;
 854    }
 855    else {
 856       /* allocate new, unshared state */
 857       shared = _mesa_alloc_shared_state(ctx);
 858       if (!shared)
 859          return GL_FALSE;
 860    }
 861
 862    _glthread_LOCK_MUTEX(shared->Mutex);
 863    ctx->Shared = shared;
 864    shared->RefCount++;
 865    _glthread_UNLOCK_MUTEX(shared->Mutex);
 866
 867    if (!init_attrib_groups( ctx )) {
 868       _mesa_release_shared_state(ctx, ctx->Shared);
 869       return GL_FALSE;
 870    }
 871
 872 #if FEATURE_dispatch
 873    /* setup the API dispatch tables */
 874    switch (ctx->API) {
 875 #if FEATURE_GL
 876    case API_OPENGL:
 877       ctx->Exec = _mesa_create_exec_table();
 878       break;
 879 #endif
 880 #if FEATURE_ES1
 881    case API_OPENGLES:
 882       ctx->Exec = _mesa_create_exec_table_es1();
 883       break;
 884 #endif
 885 #if FEATURE_ES2
 886    case API_OPENGLES2:
 887       ctx->Exec = _mesa_create_exec_table_es2();
 888       break;
 889 #endif
 890    default:
 891       _mesa_problem(ctx, "unknown or unsupported API");
 892       break;
 893    }
 894
 895    if (!ctx->Exec) {
 896       _mesa_release_shared_state(ctx, ctx->Shared);
 897       return GL_FALSE;
 898    }
 899 #endif
 900    ctx->CurrentDispatch = ctx->Exec;
 901
 902 #if FEATURE_dlist
 903    ctx->Save = _mesa_create_save_table();
 904    if (!ctx->Save) {
 905       _mesa_release_shared_state(ctx, ctx->Shared);
 906       free(ctx->Exec);
 907       return GL_FALSE;
 908    }
 909
 910    _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
 911 #endif
 912
 913    /* Neutral tnl module stuff */
 914    _mesa_init_exec_vtxfmt( ctx );
 915    ctx->TnlModule.Current = NULL;
 916    ctx->TnlModule.SwapCount = 0;
 917
 918    ctx->FragmentProgram._MaintainTexEnvProgram
 919       = (_mesa_getenv("MESA_TEX_PROG") != NULL);
 920
 921    ctx->VertexProgram._MaintainTnlProgram
 922       = (_mesa_getenv("MESA_TNL_PROG") != NULL);
 923    if (ctx->VertexProgram._MaintainTnlProgram) {
 924       /* this is required... */
 925       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
 926    }
 927
 928    switch (ctx->API) {
 929    case API_OPENGL:
 930       break;
 931    case API_OPENGLES:
 932       /**
 933        * GL_OES_texture_cube_map says
 934        * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
 935        */
 936       for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
 937          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
 938          texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
 939          texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
 940          texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
 941          texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
 942          texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
 943          texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
 944       }
 945       break;
 946    case API_OPENGLES2:
 947       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
 948       ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
 949       ctx->Point.PointSprite = GL_TRUE;  /* always on for ES 2.x */
 950       break;
 951    }
 952
 953    ctx->FirstTimeCurrent = GL_TRUE;
 954
 955    return GL_TRUE;
 956 }
 957
 958 GLboolean
 959 _mesa_initialize_context(GLcontext *ctx,
 960                          const GLvisual *visual,
 961                          GLcontext *share_list,
 962                          const struct dd_function_table *driverFunctions,
 963                          void *driverContext)
 964 {
 965    return _mesa_initialize_context_for_api(ctx,
 966                                            API_OPENGL,
 967                                            visual,
 968                                            share_list,
 969                                            driverFunctions,
 970                                            driverContext);
 971 }
 972
 973 /**
 974  * Allocate and initialize a GLcontext structure.
 975  * Note that the driver needs to pass in its dd_function_table here since
 976  * we need to at least call driverFunctions->NewTextureObject to initialize
 977  * the rendering context.
 978  *
 979  * \param api the GL API type to create the context for
 980  * \param visual a GLvisual pointer (we copy the struct contents)
 981  * \param share_list another context to share display lists with or NULL
 982  * \param driverFunctions points to the dd_function_table into which the
 983  *        driver has plugged in all its special functions.
 984  * \param driverContext points to the device driver's private context state
 985  *
 986  * \return pointer to a new __GLcontextRec or NULL if error.
 987  */
 988 GLcontext *
 989 _mesa_create_context_for_api(gl_api api,
 990                              const GLvisual *visual,
 991                              GLcontext *share_list,
 992                              const struct dd_function_table *driverFunctions,
 993                              void *driverContext)
 994 {
 995    GLcontext *ctx;
 996
 997    ASSERT(visual);
 998    /*ASSERT(driverContext);*/
 999
1000    ctx = (GLcontext *) calloc(1, sizeof(GLcontext));
1001    if (!ctx)
1002       return NULL;
1003
1004    if (_mesa_initialize_context_for_api(ctx, api, visual, share_list,
1005                                         driverFunctions, driverContext)) {
1006       return ctx;
1007    }
1008    else {
1009       free(ctx);
1010       return NULL;
1011    }
1012 }
1013
1014 GLcontext *
1015 _mesa_create_context(const GLvisual *visual,
1016                      GLcontext *share_list,
1017                      const struct dd_function_table *driverFunctions,
1018                      void *driverContext)
1019 {
1020    return _mesa_create_context_for_api(API_OPENGL, visual,
1021                                        share_list,
1022                                        driverFunctions,
1023                                        driverContext);
1024 }
1025
1026 /**
1027  * Free the data associated with the given context.
1028  *
1029  * But doesn't free the GLcontext struct itself.
1030  *
1031  * \sa _mesa_initialize_context() and init_attrib_groups().
1032  */
1033 void
1034 _mesa_free_context_data( GLcontext *ctx )
1035 {
1036    if (!_mesa_get_current_context()){
1037       /* No current context, but we may need one in order to delete
1038        * texture objs, etc.  So temporarily bind the context now.
1039        */
1040       _mesa_make_current(ctx, NULL, NULL);
1041    }
1042
1043    /* unreference WinSysDraw/Read buffers */
1044    _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
1045    _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
1046    _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
1047    _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
1048
1049    _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
1050    _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
1051    _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL);
1052
1053    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
1054    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
1055    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
1056
1057    _mesa_free_attrib_data(ctx);
1058    _mesa_free_buffer_objects(ctx);
1059    _mesa_free_lighting_data( ctx );
1060    _mesa_free_eval_data( ctx );
1061    _mesa_free_texture_data( ctx );
1062    _mesa_free_matrix_data( ctx );
1063    _mesa_free_viewport_data( ctx );
1064    _mesa_free_colortables_data( ctx );
1065    _mesa_free_program_data(ctx);
1066    _mesa_free_shader_state(ctx);
1067    _mesa_free_queryobj_data(ctx);
1068 #if FEATURE_ARB_sync
1069    _mesa_free_sync_data(ctx);
1070 #endif
1071    _mesa_free_varray_data(ctx);
1072    _mesa_free_transform_feedback(ctx);
1073
1074    _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);
1075
1076 #if FEATURE_ARB_pixel_buffer_object
1077    _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
1078    _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
1079    _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
1080 #endif
1081
1082 #if FEATURE_ARB_vertex_buffer_object
1083    _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
1084    _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);
1085 #endif
1086
1087    /* free dispatch tables */
1088    free(ctx->Exec);
1089    free(ctx->Save);
1090
1091    /* Shared context state (display lists, textures, etc) */
1092    _mesa_release_shared_state( ctx, ctx->Shared );
1093
1094    /* needs to be after freeing shared state */
1095    _mesa_free_display_list_data(ctx);
1096
1097    if (ctx->Extensions.String)
1098       free((void *) ctx->Extensions.String);
1099
1100    if (ctx->VersionString)
1101       free(ctx->VersionString);
1102
1103    /* unbind the context if it's currently bound */
1104    if (ctx == _mesa_get_current_context()) {
1105       _mesa_make_current(NULL, NULL, NULL);
1106    }
1107 }
1108
1109
1110 /**
1111  * Destroy a GLcontext structure.
1112  *
1113  * \param ctx GL context.
1114  *
1115  * Calls _mesa_free_context_data() and frees the GLcontext structure itself.
1116  */
1117 void
1118 _mesa_destroy_context( GLcontext *ctx )
1119 {
1120    if (ctx) {
1121       _mesa_free_context_data(ctx);
1122       free( (void *) ctx );
1123    }
1124 }
1125
1126
1127 #if _HAVE_FULL_GL
1128 /**
1129  * Copy attribute groups from one context to another.
1130  *
1131  * \param src source context
1132  * \param dst destination context
1133  * \param mask bitwise OR of GL_*_BIT flags
1134  *
1135  * According to the bits specified in \p mask, copies the corresponding
1136  * attributes from \p src into \p dst.  For many of the attributes a simple \c
1137  * memcpy is not enough due to the existence of internal pointers in their data
1138  * structures.
1139  */
1140 void
1141 _mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1142 {
1143    if (mask & GL_ACCUM_BUFFER_BIT) {
1144       /* OK to memcpy */
1145       dst->Accum = src->Accum;
1146    }
1147    if (mask & GL_COLOR_BUFFER_BIT) {
1148       /* OK to memcpy */
1149       dst->Color = src->Color;
1150    }
1151    if (mask & GL_CURRENT_BIT) {
1152       /* OK to memcpy */
1153       dst->Current = src->Current;
1154    }
1155    if (mask & GL_DEPTH_BUFFER_BIT) {
1156       /* OK to memcpy */
1157       dst->Depth = src->Depth;
1158    }
1159    if (mask & GL_ENABLE_BIT) {
1160       /* no op */
1161    }
1162    if (mask & GL_EVAL_BIT) {
1163       /* OK to memcpy */
1164       dst->Eval = src->Eval;
1165    }
1166    if (mask & GL_FOG_BIT) {
1167       /* OK to memcpy */
1168       dst->Fog = src->Fog;
1169    }
1170    if (mask & GL_HINT_BIT) {
1171       /* OK to memcpy */
1172       dst->Hint = src->Hint;
1173    }
1174    if (mask & GL_LIGHTING_BIT) {
1175       GLuint i;
1176       /* begin with memcpy */
1177       dst->Light = src->Light;
1178       /* fixup linked lists to prevent pointer insanity */
1179       make_empty_list( &(dst->Light.EnabledList) );
1180       for (i = 0; i < MAX_LIGHTS; i++) {
1181          if (dst->Light.Light[i].Enabled) {
1182             insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
1183          }
1184       }
1185    }
1186    if (mask & GL_LINE_BIT) {
1187       /* OK to memcpy */
1188       dst->Line = src->Line;
1189    }
1190    if (mask & GL_LIST_BIT) {
1191       /* OK to memcpy */
1192       dst->List = src->List;
1193    }
1194    if (mask & GL_PIXEL_MODE_BIT) {
1195       /* OK to memcpy */
1196       dst->Pixel = src->Pixel;
1197    }
1198    if (mask & GL_POINT_BIT) {
1199       /* OK to memcpy */
1200       dst->Point = src->Point;
1201    }
1202    if (mask & GL_POLYGON_BIT) {
1203       /* OK to memcpy */
1204       dst->Polygon = src->Polygon;
1205    }
1206    if (mask & GL_POLYGON_STIPPLE_BIT) {
1207       /* Use loop instead of memcpy due to problem with Portland Group's
1208        * C compiler.  Reported by John Stone.
1209        */
1210       GLuint i;
1211       for (i = 0; i < 32; i++) {
1212          dst->PolygonStipple[i] = src->PolygonStipple[i];
1213       }
1214    }
1215    if (mask & GL_SCISSOR_BIT) {
1216       /* OK to memcpy */
1217       dst->Scissor = src->Scissor;
1218    }
1219    if (mask & GL_STENCIL_BUFFER_BIT) {
1220       /* OK to memcpy */
1221       dst->Stencil = src->Stencil;
1222    }
1223    if (mask & GL_TEXTURE_BIT) {
1224       /* Cannot memcpy because of pointers */
1225       _mesa_copy_texture_state(src, dst);
1226    }
1227    if (mask & GL_TRANSFORM_BIT) {
1228       /* OK to memcpy */
1229       dst->Transform = src->Transform;
1230    }
1231    if (mask & GL_VIEWPORT_BIT) {
1232       /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
1233       dst->Viewport.X = src->Viewport.X;
1234       dst->Viewport.Y = src->Viewport.Y;
1235       dst->Viewport.Width = src->Viewport.Width;
1236       dst->Viewport.Height = src->Viewport.Height;
1237       dst->Viewport.Near = src->Viewport.Near;
1238       dst->Viewport.Far = src->Viewport.Far;
1239       _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
1240    }
1241
1242    /* XXX FIXME:  Call callbacks?
1243     */
1244    dst->NewState = _NEW_ALL;
1245 }
1246 #endif
1247
1248
1249 /**
1250  * Check if the given context can render into the given framebuffer
1251  * by checking visual attributes.
1252  *
1253  * Most of these tests could go away because Mesa is now pretty flexible
1254  * in terms of mixing rendering contexts with framebuffers.  As long
1255  * as RGB vs. CI mode agree, we're probably good.
1256  *
1257  * \return GL_TRUE if compatible, GL_FALSE otherwise.
1258  */
1259 static GLboolean
1260 check_compatible(const GLcontext *ctx, const GLframebuffer *buffer)
1261 {
1262    const GLvisual *ctxvis = &ctx->Visual;
1263    const GLvisual *bufvis = &buffer->Visual;
1264
1265    if (ctxvis == bufvis)
1266       return GL_TRUE;
1267
1268 #if 0
1269    /* disabling this fixes the fgl_glxgears pbuffer demo */
1270    if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
1271       return GL_FALSE;
1272 #endif
1273    if (ctxvis->stereoMode && !bufvis->stereoMode)
1274       return GL_FALSE;
1275    if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
1276       return GL_FALSE;
1277    if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
1278       return GL_FALSE;
1279    if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
1280       return GL_FALSE;
1281    if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
1282       return GL_FALSE;
1283    if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
1284       return GL_FALSE;
1285    if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
1286       return GL_FALSE;
1287 #if 0
1288    /* disabled (see bug 11161) */
1289    if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
1290       return GL_FALSE;
1291 #endif
1292    if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
1293       return GL_FALSE;
1294
1295    return GL_TRUE;
1296 }
1297
1298
1299 /**
1300  * Do one-time initialization for the given framebuffer.  Specifically,
1301  * ask the driver for the window's current size and update the framebuffer
1302  * object to match.
1303  * Really, the device driver should totally take care of this.
1304  */
1305 static void
1306 initialize_framebuffer_size(GLcontext *ctx, GLframebuffer *fb)
1307 {
1308    GLuint width, height;
1309    if (ctx->Driver.GetBufferSize) {
1310       ctx->Driver.GetBufferSize(fb, &width, &height);
1311       if (ctx->Driver.ResizeBuffers)
1312          ctx->Driver.ResizeBuffers(ctx, fb, width, height);
1313       fb->Initialized = GL_TRUE;
1314    }
1315 }
1316
1317
1318 /**
1319  * Check if the viewport/scissor size has not yet been initialized.
1320  * Initialize the size if the given width and height are non-zero.
1321  */
1322 void
1323 _mesa_check_init_viewport(GLcontext *ctx, GLuint width, GLuint height)
1324 {
1325    if (!ctx->ViewportInitialized && width > 0 && height > 0) {
1326       /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
1327        * potential infinite recursion.
1328        */
1329       ctx->ViewportInitialized = GL_TRUE;
1330       _mesa_set_viewport(ctx, 0, 0, width, height);
1331       _mesa_set_scissor(ctx, 0, 0, width, height);
1332    }
1333 }
1334
1335
1336 /**
1337  * Bind the given context to the given drawBuffer and readBuffer and
1338  * make it the current context for the calling thread.
1339  * We'll render into the drawBuffer and read pixels from the
1340  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1341  *
1342  * We check that the context's and framebuffer's visuals are compatible
1343  * and return immediately if they're not.
1344  *
1345  * \param newCtx  the new GL context. If NULL then there will be no current GL
1346  *                context.
1347  * \param drawBuffer  the drawing framebuffer
1348  * \param readBuffer  the reading framebuffer
1349  */
1350 GLboolean
1351 _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
1352                     GLframebuffer *readBuffer )
1353 {
1354    if (MESA_VERBOSE & VERBOSE_API)
1355       _mesa_debug(newCtx, "_mesa_make_current()\n");
1356
1357    /* Check that the context's and framebuffer's visuals are compatible.
1358     */
1359    if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1360       if (!check_compatible(newCtx, drawBuffer)) {
1361          _mesa_warning(newCtx,
1362               "MakeCurrent: incompatible visuals for context and drawbuffer");
1363          return GL_FALSE;
1364       }
1365    }
1366    if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1367       if (!check_compatible(newCtx, readBuffer)) {
1368          _mesa_warning(newCtx,
1369               "MakeCurrent: incompatible visuals for context and readbuffer");
1370          return GL_FALSE;
1371       }
1372    }
1373
1374    /* We used to call _glapi_check_multithread() here.  Now do it in drivers */
1375    _glapi_set_context((void *) newCtx);
1376    ASSERT(_mesa_get_current_context() == newCtx);
1377
1378    if (!newCtx) {
1379       _glapi_set_dispatch(NULL);  /* none current */
1380    }
1381    else {
1382       _glapi_set_dispatch(newCtx->CurrentDispatch);
1383
1384       if (drawBuffer && readBuffer) {
1385          /* TODO: check if newCtx and buffer's visual match??? */
1386
1387          ASSERT(drawBuffer->Name == 0);
1388          ASSERT(readBuffer->Name == 0);
1389          _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1390          _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1391
1392          /*
1393           * Only set the context's Draw/ReadBuffer fields if they're NULL
1394           * or not bound to a user-created FBO.
1395           */
1396          if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
1397             /* KW: merge conflict here, revisit.
1398              */
1399             /* fix up the fb fields - these will end up wrong otherwise
1400              * if the DRIdrawable changes, and everything relies on them.
1401              * This is a bit messy (same as needed in _mesa_BindFramebufferEXT)
1402              */
1403             unsigned int i;
1404             GLenum buffers[MAX_DRAW_BUFFERS];
1405
1406             _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1407
1408             for(i = 0; i < newCtx->Const.MaxDrawBuffers; i++) {
1409                buffers[i] = newCtx->Color.DrawBuffer[i];
1410             }
1411
1412             _mesa_drawbuffers(newCtx, newCtx->Const.MaxDrawBuffers, buffers, NULL);
1413          }
1414          if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {
1415             _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1416          }
1417
1418          /* XXX only set this flag if we're really changing the draw/read
1419           * framebuffer bindings.
1420           */
1421          newCtx->NewState |= _NEW_BUFFERS;
1422
1423 #if 1
1424          /* We want to get rid of these lines: */
1425
1426 #if _HAVE_FULL_GL
1427          if (!drawBuffer->Initialized) {
1428             initialize_framebuffer_size(newCtx, drawBuffer);
1429          }
1430          if (readBuffer != drawBuffer && !readBuffer->Initialized) {
1431             initialize_framebuffer_size(newCtx, readBuffer);
1432          }
1433
1434          _mesa_resizebuffers(newCtx);
1435 #endif
1436
1437 #else
1438          /* We want the drawBuffer and readBuffer to be initialized by
1439           * the driver.
1440           * This generally means the Width and Height match the actual
1441           * window size and the renderbuffers (both hardware and software
1442           * based) are allocated to match.  The later can generally be
1443           * done with a call to _mesa_resize_framebuffer().
1444           *
1445           * It's theoretically possible for a buffer to have zero width
1446           * or height, but for now, assert check that the driver did what's
1447           * expected of it.
1448           */
1449          ASSERT(drawBuffer->Width > 0);
1450          ASSERT(drawBuffer->Height > 0);
1451 #endif
1452
1453          if (drawBuffer) {
1454             _mesa_check_init_viewport(newCtx,
1455                                       drawBuffer->Width, drawBuffer->Height);
1456          }
1457       }
1458
1459       if (newCtx->FirstTimeCurrent) {
1460          _mesa_compute_version(newCtx);
1461
1462          check_context_limits(newCtx);
1463
1464          /* We can use this to help debug user's problems.  Tell them to set
1465           * the MESA_INFO env variable before running their app.  Then the
1466           * first time each context is made current we'll print some useful
1467           * information.
1468           */
1469          if (_mesa_getenv("MESA_INFO")) {
1470             _mesa_print_info();
1471          }
1472
1473          newCtx->FirstTimeCurrent = GL_FALSE;
1474       }
1475    }
1476
1477    return GL_TRUE;
1478 }
1479
1480
1481 /**
1482  * Make context 'ctx' share the display lists, textures and programs
1483  * that are associated with 'ctxToShare'.
1484  * Any display lists, textures or programs associated with 'ctx' will
1485  * be deleted if nobody else is sharing them.
1486  */
1487 GLboolean
1488 _mesa_share_state(GLcontext *ctx, GLcontext *ctxToShare)
1489 {
1490    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1491       struct gl_shared_state *oldSharedState = ctx->Shared;
1492
1493       ctx->Shared = ctxToShare->Shared;
1494
1495       _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1496       ctx->Shared->RefCount++;
1497       _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1498
1499       update_default_objects(ctx);
1500
1501       _mesa_release_shared_state(ctx, oldSharedState);
1502
1503       return GL_TRUE;
1504    }
1505    else {
1506       return GL_FALSE;
1507    }
1508 }
1509
1510
1511
1512 /**
1513  * \return pointer to the current GL context for this thread.
1514  *
1515  * Calls _glapi_get_context(). This isn't the fastest way to get the current
1516  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
1517  * context.h.
1518  */
1519 GLcontext *
1520 _mesa_get_current_context( void )
1521 {
1522    return (GLcontext *) _glapi_get_context();
1523 }
1524
1525
1526 /**
1527  * Get context's current API dispatch table.
1528  *
1529  * It'll either be the immediate-mode execute dispatcher or the display list
1530  * compile dispatcher.
1531  *
1532  * \param ctx GL context.
1533  *
1534  * \return pointer to dispatch_table.
1535  *
1536  * Simply returns __GLcontextRec::CurrentDispatch.
1537  */
1538 struct _glapi_table *
1539 _mesa_get_dispatch(GLcontext *ctx)
1540 {
1541    return ctx->CurrentDispatch;
1542 }
1543
1544 /*@}*/
1545
1546
1547 /**********************************************************************/
1548 /** \name Miscellaneous functions                                     */
1549 /**********************************************************************/
1550 /*@{*/
1551
1552 /**
1553  * Record an error.
1554  *
1555  * \param ctx GL context.
1556  * \param error error code.
1557  *
1558  * Records the given error code and call the driver's dd_function_table::Error
1559  * function if defined.
1560  *
1561  * \sa
1562  * This is called via _mesa_error().
1563  */
1564 void
1565 _mesa_record_error(GLcontext *ctx, GLenum error)
1566 {
1567    if (!ctx)
1568       return;
1569
1570    if (ctx->ErrorValue == GL_NO_ERROR) {
1571       ctx->ErrorValue = error;
1572    }
1573
1574    /* Call device driver's error handler, if any.  This is used on the Mac. */
1575    if (ctx->Driver.Error) {
1576       ctx->Driver.Error(ctx);
1577    }
1578 }
1579
1580
1581 /**
1582  * Flush commands and wait for completion.
1583  */
1584 void
1585 _mesa_finish(GLcontext *ctx)
1586 {
1587    FLUSH_CURRENT( ctx, 0 );
1588    if (ctx->Driver.Finish) {
1589       ctx->Driver.Finish(ctx);
1590    }
1591 }
1592
1593
1594 /**
1595  * Flush commands.
1596  */
1597 void
1598 _mesa_flush(GLcontext *ctx)
1599 {
1600    FLUSH_CURRENT( ctx, 0 );
1601    if (ctx->Driver.Flush) {
1602       ctx->Driver.Flush(ctx);
1603    }
1604 }
1605
1606
1607
1608 /**
1609  * Execute glFinish().
1610  *
1611  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1612  * dd_function_table::Finish driver callback, if not NULL.
1613  */
1614 void GLAPIENTRY
1615 _mesa_Finish(void)
1616 {
1617    GET_CURRENT_CONTEXT(ctx);
1618    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1619    _mesa_finish(ctx);
1620 }
1621
1622
1623 /**
1624  * Execute glFlush().
1625  *
1626  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1627  * dd_function_table::Flush driver callback, if not NULL.
1628  */
1629 void GLAPIENTRY
1630 _mesa_Flush(void)
1631 {
1632    GET_CURRENT_CONTEXT(ctx);
1633    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1634    _mesa_flush(ctx);
1635 }
1636
1637
1638 /**
1639  * Set mvp_with_dp4 flag.  If a driver has a preference for DP4 over
1640  * MUL/MAD, or vice versa, call this function to register that.
1641  * Otherwise we default to MUL/MAD.
1642  */
1643 void
1644 _mesa_set_mvp_with_dp4( GLcontext *ctx,
1645                         GLboolean flag )
1646 {
1647    ctx->mvp_with_dp4 = flag;
1648 }
1649
1650
1651
1652 /**
1653  * Prior to drawing anything with glBegin, glDrawArrays, etc. this function
1654  * is called to see if it's valid to render.  This involves checking that
1655  * the current shader is valid and the framebuffer is complete.
1656  * If an error is detected it'll be recorded here.
1657  * \return GL_TRUE if OK to render, GL_FALSE if not
1658  */
1659 GLboolean
1660 _mesa_valid_to_render(GLcontext *ctx, const char *where)
1661 {
1662    /* This depends on having up to date derived state (shaders) */
1663    if (ctx->NewState)
1664       _mesa_update_state(ctx);
1665
1666    if (ctx->Shader.CurrentProgram) {
1667       /* using shaders */
1668       if (!ctx->Shader.CurrentProgram->LinkStatus) {
1669          _mesa_error(ctx, GL_INVALID_OPERATION,
1670                      "%s(shader not linked), where");
1671          return GL_FALSE;
1672       }
1673 #if 0 /* not normally enabled */
1674       {
1675          char errMsg[100];
1676          if (!_mesa_validate_shader_program(ctx, ctx->Shader.CurrentProgram,
1677                                             errMsg)) {
1678             _mesa_warning(ctx, "Shader program %u is invalid: %s",
1679                           ctx->Shader.CurrentProgram->Name, errMsg);
1680          }
1681       }
1682 #endif
1683    }
1684    else {
1685       if (ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) {
1686          _mesa_error(ctx, GL_INVALID_OPERATION,
1687                      "%s(vertex program not valid)", where);
1688          return GL_FALSE;
1689       }
1690       if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
1691          _mesa_error(ctx, GL_INVALID_OPERATION,
1692                      "%s(fragment program not valid)", where);
1693          return GL_FALSE;
1694       }
1695    }
1696
1697    if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
1698       _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
1699                   "%s(incomplete framebuffer)", where);
1700       return GL_FALSE;
1701    }
1702
1703 #ifdef DEBUG
1704    if (ctx->Shader.Flags & GLSL_LOG) {
1705       struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
1706       if (shProg) {
1707          if (!shProg->_Used) {
1708             /* This is the first time this shader is being used.
1709              * Append shader's constants/uniforms to log file.
1710              */
1711             GLuint i;
1712             for (i = 0; i < shProg->NumShaders; i++) {
1713                struct gl_shader *sh = shProg->Shaders[i];
1714                if (sh->Type == GL_VERTEX_SHADER) {
1715                   _mesa_append_uniforms_to_file(sh,
1716                                                 &shProg->VertexProgram->Base);
1717                }
1718                else if (sh->Type == GL_FRAGMENT_SHADER) {
1719                   _mesa_append_uniforms_to_file(sh,
1720                                                 &shProg->FragmentProgram->Base);
1721                }
1722             }
1723             shProg->_Used = GL_TRUE;
1724          }
1725       }
1726    }
1727 #endif
1728
1729    return GL_TRUE;
1730 }
1731
1732
1733 /*@}*/