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