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