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