1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. 5 * Copyright (C) 2008 VMware, Inc. All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26 /** 27 * \file context.c 28 * Mesa context/visual/framebuffer management functions. 29 * \author Brian Paul 30 */ 31 32 /** 33 * \mainpage Mesa Main Module 34 * 35 * \section MainIntroduction Introduction 36 * 37 * The Mesa Main module consists of all the files in the main/ directory. 38 * Among the features of this module are: 39 * <UL> 40 * <LI> Structures to represent most GL state </LI> 41 * <LI> State set/get functions </LI> 42 * <LI> Display lists </LI> 43 * <LI> Texture unit, object and image handling </LI> 44 * <LI> Matrix and attribute stacks </LI> 45 * </UL> 46 * 47 * Other modules are responsible for API dispatch, vertex transformation, 48 * point/line/triangle setup, rasterization, vertex array caching, 49 * vertex/fragment programs/shaders, etc. 50 * 51 * 52 * \section AboutDoxygen About Doxygen 53 * 54 * If you're viewing this information as Doxygen-generated HTML you'll 55 * see the documentation index at the top of this page. 56 * 57 * The first line lists the Mesa source code modules. 58 * The second line lists the indexes available for viewing the documentation 59 * for each module. 60 * 61 * Selecting the <b>Main page</b> link will display a summary of the module 62 * (this page). 63 * 64 * Selecting <b>Data Structures</b> will list all C structures. 65 * 66 * Selecting the <b>File List</b> link will list all the source files in 67 * the module. 68 * Selecting a filename will show a list of all functions defined in that file. 69 * 70 * Selecting the <b>Data Fields</b> link will display a list of all 71 * documented structure members. 72 * 73 * Selecting the <b>Globals</b> link will display a list 74 * of all functions, structures, global variables and macros in the module. 75 * 76 */ 77 78 79 #include "glheader.h" 80 #include "imports.h" 81 #include "accum.h" 82 #include "api_exec.h" 83 #include "api_loopback.h" 84 #include "arrayobj.h" 85 #include "attrib.h" 86 #include "bbox.h" 87 #include "blend.h" 88 #include "buffers.h" 89 #include "bufferobj.h" 90 #include "context.h" 91 #include "cpuinfo.h" 92 #include "debug.h" 93 #include "debug_output.h" 94 #include "depth.h" 95 #include "dlist.h" 96 #include "eval.h" 97 #include "extensions.h" 98 #include "fbobject.h" 99 #include "feedback.h" 100 #include "fog.h" 101 #include "formats.h" 102 #include "framebuffer.h" 103 #include "hint.h" 104 #include "hash.h" 105 #include "light.h" 106 #include "lines.h" 107 #include "macros.h" 108 #include "matrix.h" 109 #include "multisample.h" 110 #include "performance_monitor.h" 111 #include "pipelineobj.h" 112 #include "pixel.h" 113 #include "pixelstore.h" 114 #include "points.h" 115 #include "polygon.h" 116 #include "queryobj.h" 117 #include "syncobj.h" 118 #include "rastpos.h" 119 #include "remap.h" 120 #include "scissor.h" 121 #include "shared.h" 122 #include "shaderobj.h" 123 #include "shaderimage.h" 124 #include "util/strtod.h" 125 #include "stencil.h" 126 #include "texcompress_s3tc.h" 127 #include "texstate.h" 128 #include "transformfeedback.h" 129 #include "mtypes.h" 130 #include "varray.h" 131 #include "version.h" 132 #include "viewport.h" 133 #include "program/program.h" 134 #include "math/m_matrix.h" 135 #include "main/dispatch.h" /* for _gloffset_COUNT */ 136 #include "macros.h" 137 138 #ifdef USE_SPARC_ASM 139 #include "sparc/sparc.h" 140 #endif 141 142 #include "compiler/glsl_types.h" 143 #include "compiler/glsl/glsl_parser_extras.h" 144 #include <stdbool.h> 145 146 147 #ifndef MESA_VERBOSE 148 int MESA_VERBOSE = 0; 149 #endif 150 151 #ifndef MESA_DEBUG_FLAGS 152 int MESA_DEBUG_FLAGS = 0; 153 #endif 154 155 156 /* ubyte -> float conversion */ 157 GLfloat _mesa_ubyte_to_float_color_tab[256]; 158 159 160 161 /** 162 * Swap buffers notification callback. 163 * 164 * \param ctx GL context. 165 * 166 * Called by window system just before swapping buffers. 167 * We have to finish any pending rendering. 168 */ 169 void 170 _mesa_notifySwapBuffers(struct gl_context *ctx) 171 { 172 if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS) 173 _mesa_debug(ctx, "SwapBuffers\n"); 174 FLUSH_CURRENT( ctx, 0 ); 175 if (ctx->Driver.Flush) { 176 ctx->Driver.Flush(ctx); 177 } 178 } 179 180 181 /**********************************************************************/ 182 /** \name GL Visual allocation/destruction */ 183 /**********************************************************************/ 184 /*@{*/ 185 186 /** 187 * Allocates a struct gl_config structure and initializes it via 188 * _mesa_initialize_visual(). 189 * 190 * \param dbFlag double buffering 191 * \param stereoFlag stereo buffer 192 * \param depthBits requested bits per depth buffer value. Any value in [0, 32] 193 * is acceptable but the actual depth type will be GLushort or GLuint as 194 * needed. 195 * \param stencilBits requested minimum bits per stencil buffer value 196 * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number 197 * of bits per color component in accum buffer. 198 * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE 199 * \param redBits number of bits per color component in frame buffer for RGB(A) 200 * mode. We always use 8 in core Mesa though. 201 * \param greenBits same as above. 202 * \param blueBits same as above. 203 * \param alphaBits same as above. 204 * \param numSamples not really used. 205 * 206 * \return pointer to new struct gl_config or NULL if requested parameters 207 * can't be met. 208 * 209 * \note Need to add params for level and numAuxBuffers (at least) 210 */ 211 struct gl_config * 212 _mesa_create_visual( GLboolean dbFlag, 213 GLboolean stereoFlag, 214 GLint redBits, 215 GLint greenBits, 216 GLint blueBits, 217 GLint alphaBits, 218 GLint depthBits, 219 GLint stencilBits, 220 GLint accumRedBits, 221 GLint accumGreenBits, 222 GLint accumBlueBits, 223 GLint accumAlphaBits, 224 GLint numSamples ) 225 { 226 struct gl_config *vis = CALLOC_STRUCT(gl_config); 227 if (vis) { 228 if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag, 229 redBits, greenBits, blueBits, alphaBits, 230 depthBits, stencilBits, 231 accumRedBits, accumGreenBits, 232 accumBlueBits, accumAlphaBits, 233 numSamples)) { 234 free(vis); 235 return NULL; 236 } 237 } 238 return vis; 239 } 240 241 242 /** 243 * Makes some sanity checks and fills in the fields of the struct 244 * gl_config object with the given parameters. If the caller needs to 245 * set additional fields, he should just probably init the whole 246 * gl_config object himself. 247 * 248 * \return GL_TRUE on success, or GL_FALSE on failure. 249 * 250 * \sa _mesa_create_visual() above for the parameter description. 251 */ 252 GLboolean 253 _mesa_initialize_visual( struct gl_config *vis, 254 GLboolean dbFlag, 255 GLboolean stereoFlag, 256 GLint redBits, 257 GLint greenBits, 258 GLint blueBits, 259 GLint alphaBits, 260 GLint depthBits, 261 GLint stencilBits, 262 GLint accumRedBits, 263 GLint accumGreenBits, 264 GLint accumBlueBits, 265 GLint accumAlphaBits, 266 GLint numSamples ) 267 { 268 assert(vis); 269 270 if (depthBits < 0 || depthBits > 32) { 271 return GL_FALSE; 272 } 273 if (stencilBits < 0 || stencilBits > 8) { 274 return GL_FALSE; 275 } 276 assert(accumRedBits >= 0); 277 assert(accumGreenBits >= 0); 278 assert(accumBlueBits >= 0); 279 assert(accumAlphaBits >= 0); 280 281 vis->rgbMode = GL_TRUE; 282 vis->doubleBufferMode = dbFlag; 283 vis->stereoMode = stereoFlag; 284 285 vis->redBits = redBits; 286 vis->greenBits = greenBits; 287 vis->blueBits = blueBits; 288 vis->alphaBits = alphaBits; 289 vis->rgbBits = redBits + greenBits + blueBits; 290 291 vis->indexBits = 0; 292 vis->depthBits = depthBits; 293 vis->stencilBits = stencilBits; 294 295 vis->accumRedBits = accumRedBits; 296 vis->accumGreenBits = accumGreenBits; 297 vis->accumBlueBits = accumBlueBits; 298 vis->accumAlphaBits = accumAlphaBits; 299 300 vis->haveAccumBuffer = accumRedBits > 0; 301 vis->haveDepthBuffer = depthBits > 0; 302 vis->haveStencilBuffer = stencilBits > 0; 303 304 vis->numAuxBuffers = 0; 305 vis->level = 0; 306 vis->sampleBuffers = numSamples > 0 ? 1 : 0; 307 vis->samples = numSamples; 308 309 return GL_TRUE; 310 } 311 312 313 /** 314 * Destroy a visual and free its memory. 315 * 316 * \param vis visual. 317 * 318 * Frees the visual structure. 319 */ 320 void 321 _mesa_destroy_visual( struct gl_config *vis ) 322 { 323 free(vis); 324 } 325 326 /*@}*/ 327 328 329 /**********************************************************************/ 330 /** \name Context allocation, initialization, destroying 331 * 332 * The purpose of the most initialization functions here is to provide the 333 * default state values according to the OpenGL specification. 334 */ 335 /**********************************************************************/ 336 /*@{*/ 337 338 339 /** 340 * One-time initialization mutex lock. 341 * 342 * \sa Used by one_time_init(). 343 */ 344 mtx_t OneTimeLock = _MTX_INITIALIZER_NP; 345 346 347 /** 348 * Calls all the various one-time-fini functions in Mesa 349 */ 350 351 static void 352 one_time_fini(void) 353 { 354 _mesa_destroy_shader_compiler(); 355 _mesa_locale_fini(); 356 } 357 358 /** 359 * Calls all the various one-time-init functions in Mesa. 360 * 361 * While holding a global mutex lock, calls several initialization functions, 362 * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is 363 * defined. 364 * 365 * \sa _math_init(). 366 */ 367 static void 368 one_time_init( struct gl_context *ctx ) 369 { 370 static GLbitfield api_init_mask = 0x0; 371 372 mtx_lock(&OneTimeLock); 373 374 /* truly one-time init */ 375 if (!api_init_mask) { 376 GLuint i; 377 378 STATIC_ASSERT(sizeof(GLbyte) == 1); 379 STATIC_ASSERT(sizeof(GLubyte) == 1); 380 STATIC_ASSERT(sizeof(GLshort) == 2); 381 STATIC_ASSERT(sizeof(GLushort) == 2); 382 STATIC_ASSERT(sizeof(GLint) == 4); 383 STATIC_ASSERT(sizeof(GLuint) == 4); 384 385 _mesa_locale_init(); 386 387 _mesa_one_time_init_extension_overrides(); 388 389 _mesa_get_cpu_features(); 390 391 for (i = 0; i < 256; i++) { 392 _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F; 393 } 394 395 atexit(one_time_fini); 396 397 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__) 398 if (MESA_VERBOSE != 0) { 399 _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n", 400 PACKAGE_VERSION, __DATE__, __TIME__); 401 } 402 #endif 403 } 404 405 /* per-API one-time init */ 406 if (!(api_init_mask & (1 << ctx->API))) { 407 _mesa_init_remap_table(); 408 } 409 410 api_init_mask |= 1 << ctx->API; 411 412 mtx_unlock(&OneTimeLock); 413 } 414 415 416 /** 417 * Initialize fields of gl_current_attrib (aka ctx->Current.*) 418 */ 419 static void 420 _mesa_init_current(struct gl_context *ctx) 421 { 422 GLuint i; 423 424 /* Init all to (0,0,0,1) */ 425 for (i = 0; i < ARRAY_SIZE(ctx->Current.Attrib); i++) { 426 ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 ); 427 } 428 429 /* redo special cases: */ 430 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 ); 431 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 ); 432 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 ); 433 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 ); 434 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 ); 435 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 ); 436 } 437 438 439 /** 440 * Init vertex/fragment/geometry program limits. 441 * Important: drivers should override these with actual limits. 442 */ 443 static void 444 init_program_limits(struct gl_constants *consts, gl_shader_stage stage, 445 struct gl_program_constants *prog) 446 { 447 prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS; 448 prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS; 449 prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS; 450 prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS; 451 prog->MaxTemps = MAX_PROGRAM_TEMPS; 452 prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS; 453 prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS; 454 prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS; 455 456 switch (stage) { 457 case MESA_SHADER_VERTEX: 458 prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS; 459 prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS; 460 prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS; 461 prog->MaxUniformComponents = 4 * MAX_UNIFORMS; 462 prog->MaxInputComponents = 0; /* value not used */ 463 prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */ 464 break; 465 case MESA_SHADER_FRAGMENT: 466 prog->MaxParameters = MAX_FRAGMENT_PROGRAM_PARAMS; 467 prog->MaxAttribs = MAX_FRAGMENT_PROGRAM_INPUTS; 468 prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS; 469 prog->MaxUniformComponents = 4 * MAX_UNIFORMS; 470 prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */ 471 prog->MaxOutputComponents = 0; /* value not used */ 472 break; 473 case MESA_SHADER_TESS_CTRL: 474 case MESA_SHADER_TESS_EVAL: 475 case MESA_SHADER_GEOMETRY: 476 prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS; 477 prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS; 478 prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS; 479 prog->MaxUniformComponents = 4 * MAX_UNIFORMS; 480 prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */ 481 prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */ 482 break; 483 case MESA_SHADER_COMPUTE: 484 prog->MaxParameters = 0; /* not meaningful for compute shaders */ 485 prog->MaxAttribs = 0; /* not meaningful for compute shaders */ 486 prog->MaxAddressRegs = 0; /* not meaningful for compute shaders */ 487 prog->MaxUniformComponents = 4 * MAX_UNIFORMS; 488 prog->MaxInputComponents = 0; /* not meaningful for compute shaders */ 489 prog->MaxOutputComponents = 0; /* not meaningful for compute shaders */ 490 break; 491 default: 492 assert(0 && "Bad shader stage in init_program_limits()"); 493 } 494 495 /* Set the native limits to zero. This implies that there is no native 496 * support for shaders. Let the drivers fill in the actual values. 497 */ 498 prog->MaxNativeInstructions = 0; 499 prog->MaxNativeAluInstructions = 0; 500 prog->MaxNativeTexInstructions = 0; 501 prog->MaxNativeTexIndirections = 0; 502 prog->MaxNativeAttribs = 0; 503 prog->MaxNativeTemps = 0; 504 prog->MaxNativeAddressRegs = 0; 505 prog->MaxNativeParameters = 0; 506 507 /* Set GLSL datatype range/precision info assuming IEEE float values. 508 * Drivers should override these defaults as needed. 509 */ 510 prog->MediumFloat.RangeMin = 127; 511 prog->MediumFloat.RangeMax = 127; 512 prog->MediumFloat.Precision = 23; 513 prog->LowFloat = prog->HighFloat = prog->MediumFloat; 514 515 /* Assume ints are stored as floats for now, since this is the least-common 516 * denominator. The OpenGL ES spec implies (page 132) that the precision 517 * of integer types should be 0. Practically speaking, IEEE 518 * single-precision floating point values can only store integers in the 519 * range [-0x01000000, 0x01000000] without loss of precision. 520 */ 521 prog->MediumInt.RangeMin = 24; 522 prog->MediumInt.RangeMax = 24; 523 prog->MediumInt.Precision = 0; 524 prog->LowInt = prog->HighInt = prog->MediumInt; 525 526 prog->MaxUniformBlocks = 12; 527 prog->MaxCombinedUniformComponents = (prog->MaxUniformComponents + 528 consts->MaxUniformBlockSize / 4 * 529 prog->MaxUniformBlocks); 530 531 prog->MaxAtomicBuffers = 0; 532 prog->MaxAtomicCounters = 0; 533 534 prog->MaxShaderStorageBlocks = 8; 535 } 536 537 538 /** 539 * Initialize fields of gl_constants (aka ctx->Const.*). 540 * Use defaults from config.h. The device drivers will often override 541 * some of these values (such as number of texture units). 542 */ 543 void 544 _mesa_init_constants(struct gl_constants *consts, gl_api api) 545 { 546 int i; 547 assert(consts); 548 549 /* Constants, may be overriden (usually only reduced) by device drivers */ 550 consts->MaxTextureMbytes = MAX_TEXTURE_MBYTES; 551 consts->MaxTextureLevels = MAX_TEXTURE_LEVELS; 552 consts->Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS; 553 consts->MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS; 554 consts->MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE; 555 consts->MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS; 556 consts->MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS; 557 consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS; 558 consts->MaxTextureUnits = MIN2(consts->MaxTextureCoordUnits, 559 consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits); 560 consts->MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY; 561 consts->MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS; 562 consts->MaxTextureBufferSize = 65536; 563 consts->TextureBufferOffsetAlignment = 1; 564 consts->MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE; 565 consts->SubPixelBits = SUB_PIXEL_BITS; 566 consts->MinPointSize = MIN_POINT_SIZE; 567 consts->MaxPointSize = MAX_POINT_SIZE; 568 consts->MinPointSizeAA = MIN_POINT_SIZE; 569 consts->MaxPointSizeAA = MAX_POINT_SIZE; 570 consts->PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY; 571 consts->MinLineWidth = MIN_LINE_WIDTH; 572 consts->MaxLineWidth = MAX_LINE_WIDTH; 573 consts->MinLineWidthAA = MIN_LINE_WIDTH; 574 consts->MaxLineWidthAA = MAX_LINE_WIDTH; 575 consts->LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY; 576 consts->MaxClipPlanes = 6; 577 consts->MaxLights = MAX_LIGHTS; 578 consts->MaxShininess = 128.0; 579 consts->MaxSpotExponent = 128.0; 580 consts->MaxViewportWidth = 16384; 581 consts->MaxViewportHeight = 16384; 582 consts->MinMapBufferAlignment = 64; 583 584 /* Driver must override these values if ARB_viewport_array is supported. */ 585 consts->MaxViewports = 1; 586 consts->ViewportSubpixelBits = 0; 587 consts->ViewportBounds.Min = 0; 588 consts->ViewportBounds.Max = 0; 589 590 /** GL_ARB_uniform_buffer_object */ 591 consts->MaxCombinedUniformBlocks = 36; 592 consts->MaxUniformBufferBindings = 36; 593 consts->MaxUniformBlockSize = 16384; 594 consts->UniformBufferOffsetAlignment = 1; 595 596 /** GL_ARB_shader_storage_buffer_object */ 597 consts->MaxCombinedShaderStorageBlocks = 8; 598 consts->MaxShaderStorageBufferBindings = 8; 599 consts->MaxShaderStorageBlockSize = 128 * 1024 * 1024; /* 2^27 */ 600 consts->ShaderStorageBufferOffsetAlignment = 256; 601 602 /* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */ 603 consts->MaxUserAssignableUniformLocations = 604 4 * MESA_SHADER_STAGES * MAX_UNIFORMS; 605 606 for (i = 0; i < MESA_SHADER_STAGES; i++) 607 init_program_limits(consts, i, &consts->Program[i]); 608 609 consts->MaxProgramMatrices = MAX_PROGRAM_MATRICES; 610 consts->MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH; 611 612 /* Assume that if GLSL 1.30+ (or GLSL ES 3.00+) is supported that 613 * gl_VertexID is implemented using a native hardware register with OpenGL 614 * semantics. 615 */ 616 consts->VertexID_is_zero_based = false; 617 618 /* GL_ARB_draw_buffers */ 619 consts->MaxDrawBuffers = MAX_DRAW_BUFFERS; 620 621 consts->MaxColorAttachments = MAX_COLOR_ATTACHMENTS; 622 consts->MaxRenderbufferSize = MAX_RENDERBUFFER_SIZE; 623 624 consts->Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS; 625 consts->MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS; 626 consts->MaxVarying = 16; /* old limit not to break tnl and swrast */ 627 consts->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS; 628 consts->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES; 629 consts->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS; 630 631 /* Shading language version */ 632 consts->GLSLVersion = 120; 633 _mesa_override_glsl_version(consts); 634 635 #ifdef DEBUG 636 consts->GenerateTemporaryNames = true; 637 #else 638 consts->GenerateTemporaryNames = false; 639 #endif 640 641 /* GL_ARB_framebuffer_object */ 642 consts->MaxSamples = 0; 643 644 /* GLSL default if NativeIntegers == FALSE */ 645 consts->UniformBooleanTrue = FLOAT_AS_UNION(1.0f).u; 646 647 /* GL_ARB_sync */ 648 consts->MaxServerWaitTimeout = 0x1fff7fffffffULL; 649 650 /* GL_EXT_provoking_vertex */ 651 consts->QuadsFollowProvokingVertexConvention = GL_TRUE; 652 653 /** GL_ARB_viewport_array */ 654 consts->LayerAndVPIndexProvokingVertex = GL_UNDEFINED_VERTEX; 655 656 /* GL_EXT_transform_feedback */ 657 consts->MaxTransformFeedbackBuffers = MAX_FEEDBACK_BUFFERS; 658 consts->MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS; 659 consts->MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS; 660 consts->MaxVertexStreams = 1; 661 662 /* GL 3.2 */ 663 consts->ProfileMask = api == API_OPENGL_CORE 664 ? GL_CONTEXT_CORE_PROFILE_BIT 665 : GL_CONTEXT_COMPATIBILITY_PROFILE_BIT; 666 667 /* GL 4.4 */ 668 consts->MaxVertexAttribStride = 2048; 669 670 /** GL_EXT_gpu_shader4 */ 671 consts->MinProgramTexelOffset = -8; 672 consts->MaxProgramTexelOffset = 7; 673 674 /* GL_ARB_texture_gather */ 675 consts->MinProgramTextureGatherOffset = -8; 676 consts->MaxProgramTextureGatherOffset = 7; 677 678 /* GL_ARB_robustness */ 679 consts->ResetStrategy = GL_NO_RESET_NOTIFICATION_ARB; 680 681 /* GL_KHR_robustness */ 682 consts->RobustAccess = GL_FALSE; 683 684 /* ES 3.0 or ARB_ES3_compatibility */ 685 consts->MaxElementIndex = 0xffffffffu; 686 687 /* GL_ARB_texture_multisample */ 688 consts->MaxColorTextureSamples = 1; 689 consts->MaxDepthTextureSamples = 1; 690 consts->MaxIntegerSamples = 1; 691 692 /* GL_ARB_shader_atomic_counters */ 693 consts->MaxAtomicBufferBindings = MAX_COMBINED_ATOMIC_BUFFERS; 694 consts->MaxAtomicBufferSize = MAX_ATOMIC_COUNTERS * ATOMIC_COUNTER_SIZE; 695 consts->MaxCombinedAtomicBuffers = MAX_COMBINED_ATOMIC_BUFFERS; 696 consts->MaxCombinedAtomicCounters = MAX_ATOMIC_COUNTERS; 697 698 /* GL_ARB_vertex_attrib_binding */ 699 consts->MaxVertexAttribRelativeOffset = 2047; 700 consts->MaxVertexAttribBindings = MAX_VERTEX_GENERIC_ATTRIBS; 701 702 /* GL_ARB_compute_shader */ 703 consts->MaxComputeWorkGroupCount[0] = 65535; 704 consts->MaxComputeWorkGroupCount[1] = 65535; 705 consts->MaxComputeWorkGroupCount[2] = 65535; 706 consts->MaxComputeWorkGroupSize[0] = 1024; 707 consts->MaxComputeWorkGroupSize[1] = 1024; 708 consts->MaxComputeWorkGroupSize[2] = 64; 709 /* Enables compute support for GLES 3.1 if >= 128 */ 710 consts->MaxComputeWorkGroupInvocations = 0; 711 712 /** GL_ARB_gpu_shader5 */ 713 consts->MinFragmentInterpolationOffset = MIN_FRAGMENT_INTERPOLATION_OFFSET; 714 consts->MaxFragmentInterpolationOffset = MAX_FRAGMENT_INTERPOLATION_OFFSET; 715 716 /** GL_KHR_context_flush_control */ 717 consts->ContextReleaseBehavior = GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH; 718 719 /** GL_ARB_tessellation_shader */ 720 consts->MaxTessGenLevel = MAX_TESS_GEN_LEVEL; 721 consts->MaxPatchVertices = MAX_PATCH_VERTICES; 722 consts->Program[MESA_SHADER_TESS_CTRL].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS; 723 consts->Program[MESA_SHADER_TESS_EVAL].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS; 724 consts->MaxTessPatchComponents = MAX_TESS_PATCH_COMPONENTS; 725 consts->MaxTessControlTotalOutputComponents = MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS; 726 consts->PrimitiveRestartForPatches = false; 727 728 /** GL_ARB_compute_variable_group_size */ 729 consts->MaxComputeVariableGroupSize[0] = 512; 730 consts->MaxComputeVariableGroupSize[1] = 512; 731 consts->MaxComputeVariableGroupSize[2] = 64; 732 consts->MaxComputeVariableGroupInvocations = 512; 733 } 734 735 736 /** 737 * Do some sanity checks on the limits/constants for the given context. 738 * Only called the first time a context is bound. 739 */ 740 static void 741 check_context_limits(struct gl_context *ctx) 742 { 743 (void) ctx; 744 745 /* check that we don't exceed the size of various bitfields */ 746 assert(VARYING_SLOT_MAX <= 747 (8 * sizeof(ctx->VertexProgram._Current->info.outputs_written))); 748 assert(VARYING_SLOT_MAX <= 749 (8 * sizeof(ctx->FragmentProgram._Current->info.inputs_read))); 750 751 /* shader-related checks */ 752 assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS); 753 assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS); 754 755 /* Texture unit checks */ 756 assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits > 0); 757 assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS); 758 assert(ctx->Const.MaxTextureCoordUnits > 0); 759 assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS); 760 assert(ctx->Const.MaxTextureUnits > 0); 761 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS); 762 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS); 763 assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits, 764 ctx->Const.MaxTextureCoordUnits)); 765 assert(ctx->Const.MaxCombinedTextureImageUnits > 0); 766 assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS); 767 assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS); 768 /* number of coord units cannot be greater than number of image units */ 769 assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits); 770 771 772 /* Texture size checks */ 773 assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS); 774 assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS); 775 assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS); 776 assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE); 777 778 /* Texture level checks */ 779 assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS); 780 assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS); 781 782 /* Max texture size should be <= max viewport size (render to texture) */ 783 assert((1U << (ctx->Const.MaxTextureLevels - 1)) 784 <= ctx->Const.MaxViewportWidth); 785 assert((1U << (ctx->Const.MaxTextureLevels - 1)) 786 <= ctx->Const.MaxViewportHeight); 787 788 assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS); 789 790 /* if this fails, add more enum values to gl_buffer_index */ 791 assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT); 792 793 /* XXX probably add more tests */ 794 } 795 796 797 /** 798 * Initialize the attribute groups in a GL context. 799 * 800 * \param ctx GL context. 801 * 802 * Initializes all the attributes, calling the respective <tt>init*</tt> 803 * functions for the more complex data structures. 804 */ 805 static GLboolean 806 init_attrib_groups(struct gl_context *ctx) 807 { 808 assert(ctx); 809 810 /* Constants */ 811 _mesa_init_constants(&ctx->Const, ctx->API); 812 813 /* Extensions */ 814 _mesa_init_extensions(&ctx->Extensions); 815 816 /* Attribute Groups */ 817 _mesa_init_accum( ctx ); 818 _mesa_init_attrib( ctx ); 819 _mesa_init_bbox( ctx ); 820 _mesa_init_buffer_objects( ctx ); 821 _mesa_init_color( ctx ); 822 _mesa_init_current( ctx ); 823 _mesa_init_depth( ctx ); 824 _mesa_init_debug( ctx ); 825 _mesa_init_debug_output( ctx ); 826 _mesa_init_display_list( ctx ); 827 _mesa_init_eval( ctx ); 828 _mesa_init_fbobjects( ctx ); 829 _mesa_init_feedback( ctx ); 830 _mesa_init_fog( ctx ); 831 _mesa_init_hint( ctx ); 832 _mesa_init_image_units( ctx ); 833 _mesa_init_line( ctx ); 834 _mesa_init_lighting( ctx ); 835 _mesa_init_matrix( ctx ); 836 _mesa_init_multisample( ctx ); 837 _mesa_init_performance_monitors( ctx ); 838 _mesa_init_pipeline( ctx ); 839 _mesa_init_pixel( ctx ); 840 _mesa_init_pixelstore( ctx ); 841 _mesa_init_point( ctx ); 842 _mesa_init_polygon( ctx ); 843 _mesa_init_program( ctx ); 844 _mesa_init_queryobj( ctx ); 845 _mesa_init_sync( ctx ); 846 _mesa_init_rastpos( ctx ); 847 _mesa_init_scissor( ctx ); 848 _mesa_init_shader_state( ctx ); 849 _mesa_init_stencil( ctx ); 850 _mesa_init_transform( ctx ); 851 _mesa_init_transform_feedback( ctx ); 852 _mesa_init_varray( ctx ); 853 _mesa_init_viewport( ctx ); 854 855 if (!_mesa_init_texture( ctx )) 856 return GL_FALSE; 857 858 _mesa_init_texture_s3tc( ctx ); 859 860 /* Miscellaneous */ 861 ctx->NewState = _NEW_ALL; 862 ctx->NewDriverState = ~0; 863 ctx->ErrorValue = GL_NO_ERROR; 864 ctx->ShareGroupReset = false; 865 ctx->varying_vp_inputs = VERT_BIT_ALL; 866 867 return GL_TRUE; 868 } 869 870 871 /** 872 * Update default objects in a GL context with respect to shared state. 873 * 874 * \param ctx GL context. 875 * 876 * Removes references to old default objects, (texture objects, program 877 * objects, etc.) and changes to reference those from the current shared 878 * state. 879 */ 880 static GLboolean 881 update_default_objects(struct gl_context *ctx) 882 { 883 assert(ctx); 884 885 _mesa_update_default_objects_program(ctx); 886 _mesa_update_default_objects_texture(ctx); 887 _mesa_update_default_objects_buffer_objects(ctx); 888 889 return GL_TRUE; 890 } 891 892 893 /* XXX this is temporary and should be removed at some point in the 894 * future when there's a reasonable expectation that the libGL library 895 * contains the _glapi_new_nop_table() and _glapi_set_nop_handler() 896 * functions which were added in Mesa 10.6. 897 */ 898 #if !defined(_WIN32) 899 /* Avoid libGL / driver ABI break */ 900 #define USE_GLAPI_NOP_FEATURES 0 901 #else 902 #define USE_GLAPI_NOP_FEATURES 1 903 #endif 904 905 906 /** 907 * This function is called by the glapi no-op functions. For each OpenGL 908 * function/entrypoint there's a simple no-op function. These "no-op" 909 * functions call this function. 910 * 911 * If there's a current OpenGL context for the calling thread, we record a 912 * GL_INVALID_OPERATION error. This can happen either because the app's 913 * calling an unsupported extension function, or calling an illegal function 914 * (such as glClear between glBegin/glEnd). 915 * 916 * If there's no current OpenGL context for the calling thread, we can 917 * print a message to stderr. 918 * 919 * \param name the name of the OpenGL function 920 */ 921 #if USE_GLAPI_NOP_FEATURES 922 static void 923 nop_handler(const char *name) 924 { 925 GET_CURRENT_CONTEXT(ctx); 926 if (ctx) { 927 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(invalid call)", name); 928 } 929 #if defined(DEBUG) 930 else if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG")) { 931 fprintf(stderr, 932 "GL User Error: gl%s called without a rendering context\n", 933 name); 934 fflush(stderr); 935 } 936 #endif 937 } 938 #endif 939 940 941 /** 942 * Special no-op glFlush, see below. 943 */ 944 #if defined(_WIN32) 945 static void GLAPIENTRY 946 nop_glFlush(void) 947 { 948 /* don't record an error like we do in nop_handler() */ 949 } 950 #endif 951 952 953 #if !USE_GLAPI_NOP_FEATURES 954 static int 955 generic_nop(void) 956 { 957 GET_CURRENT_CONTEXT(ctx); 958 _mesa_error(ctx, GL_INVALID_OPERATION, 959 "unsupported function called " 960 "(unsupported extension or deprecated function?)"); 961 return 0; 962 } 963 #endif 964 965 966 /** 967 * Create a new API dispatch table in which all entries point to the 968 * generic_nop() function. This will not work on Windows because of 969 * the __stdcall convention which requires the callee to clean up the 970 * call stack. That's impossible with one generic no-op function. 971 */ 972 struct _glapi_table * 973 _mesa_new_nop_table(unsigned numEntries) 974 { 975 struct _glapi_table *table; 976 977 #if !USE_GLAPI_NOP_FEATURES 978 table = malloc(numEntries * sizeof(_glapi_proc)); 979 if (table) { 980 _glapi_proc *entry = (_glapi_proc *) table; 981 unsigned i; 982 for (i = 0; i < numEntries; i++) { 983 entry[i] = (_glapi_proc) generic_nop; 984 } 985 } 986 #else 987 table = _glapi_new_nop_table(numEntries); 988 #endif 989 return table; 990 } 991 992 993 /** 994 * Allocate and initialize a new dispatch table. The table will be 995 * populated with pointers to "no-op" functions. In turn, the no-op 996 * functions will call nop_handler() above. 997 */ 998 static struct _glapi_table * 999 alloc_dispatch_table(void) 1000 { 1001 /* Find the larger of Mesa's dispatch table and libGL's dispatch table. 1002 * In practice, this'll be the same for stand-alone Mesa. But for DRI 1003 * Mesa we do this to accommodate different versions of libGL and various 1004 * DRI drivers. 1005 */ 1006 int numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT); 1007 1008 struct _glapi_table *table = _mesa_new_nop_table(numEntries); 1009 1010 #if defined(_WIN32) 1011 if (table) { 1012 /* This is a special case for Windows in the event that 1013 * wglGetProcAddress is called between glBegin/End(). 1014 * 1015 * The MS opengl32.dll library apparently calls glFlush from 1016 * wglGetProcAddress(). If we're inside glBegin/End(), glFlush 1017 * will dispatch to _mesa_generic_nop() and we'll generate a 1018 * GL_INVALID_OPERATION error. 1019 * 1020 * The specific case which hits this is piglit's primitive-restart 1021 * test which calls glPrimitiveRestartNV() inside glBegin/End. The 1022 * first time we call glPrimitiveRestartNV() Piglit's API dispatch 1023 * code will try to resolve the function by calling wglGetProcAddress. 1024 * This raises GL_INVALID_OPERATION and an assert(glGetError()==0) 1025 * will fail causing the test to fail. By suppressing the error, the 1026 * assertion passes and the test continues. 1027 */ 1028 SET_Flush(table, nop_glFlush); 1029 } 1030 #endif 1031 1032 #if USE_GLAPI_NOP_FEATURES 1033 _glapi_set_nop_handler(nop_handler); 1034 #endif 1035 1036 return table; 1037 } 1038 1039 /** 1040 * Creates a minimal dispatch table for use within glBegin()/glEnd(). 1041 * 1042 * This ensures that we generate GL_INVALID_OPERATION errors from most 1043 * functions, since the set of functions that are valid within Begin/End is 1044 * very small. 1045 * 1046 * From the GL 1.0 specification section 2.6.3, "GL Commands within 1047 * Begin/End" 1048 * 1049 * "The only GL commands that are allowed within any Begin/End pairs are 1050 * the commands for specifying vertex coordinates, vertex color, normal 1051 * coordinates, and texture coordinates (Vertex, Color, Index, Normal, 1052 * TexCoord), EvalCoord and EvalPoint commands (see section 5.1), 1053 * commands for specifying lighting material parameters (Material 1054 * commands see section 2.12.2), display list invocation commands 1055 * (CallList and CallLists see section 5.4), and the EdgeFlag 1056 * command. Executing Begin after Begin has already been executed but 1057 * before an End is issued generates the INVALID OPERATION error, as does 1058 * executing End without a previous corresponding Begin. Executing any 1059 * other GL command within Begin/End results in the error INVALID 1060 * OPERATION." 1061 * 1062 * The table entries for specifying vertex attributes are set up by 1063 * install_vtxfmt() and _mesa_loopback_init_api_table(), and End() and dlists 1064 * are set by install_vtxfmt() as well. 1065 */ 1066 static struct _glapi_table * 1067 create_beginend_table(const struct gl_context *ctx) 1068 { 1069 struct _glapi_table *table; 1070 1071 table = alloc_dispatch_table(); 1072 if (!table) 1073 return NULL; 1074 1075 /* Fill in functions which return a value, since they should return some 1076 * specific value even if they emit a GL_INVALID_OPERATION error from them 1077 * being called within glBegin()/glEnd(). 1078 */ 1079 #define COPY_DISPATCH(func) SET_##func(table, GET_##func(ctx->Exec)) 1080 1081 COPY_DISPATCH(GenLists); 1082 COPY_DISPATCH(IsProgram); 1083 COPY_DISPATCH(IsVertexArray); 1084 COPY_DISPATCH(IsBuffer); 1085 COPY_DISPATCH(IsEnabled); 1086 COPY_DISPATCH(IsEnabledi); 1087 COPY_DISPATCH(IsRenderbuffer); 1088 COPY_DISPATCH(IsFramebuffer); 1089 COPY_DISPATCH(CheckFramebufferStatus); 1090 COPY_DISPATCH(RenderMode); 1091 COPY_DISPATCH(GetString); 1092 COPY_DISPATCH(GetStringi); 1093 COPY_DISPATCH(GetPointerv); 1094 COPY_DISPATCH(IsQuery); 1095 COPY_DISPATCH(IsSampler); 1096 COPY_DISPATCH(IsSync); 1097 COPY_DISPATCH(IsTexture); 1098 COPY_DISPATCH(IsTransformFeedback); 1099 COPY_DISPATCH(DeleteQueries); 1100 COPY_DISPATCH(AreTexturesResident); 1101 COPY_DISPATCH(FenceSync); 1102 COPY_DISPATCH(ClientWaitSync); 1103 COPY_DISPATCH(MapBuffer); 1104 COPY_DISPATCH(UnmapBuffer); 1105 COPY_DISPATCH(MapBufferRange); 1106 COPY_DISPATCH(ObjectPurgeableAPPLE); 1107 COPY_DISPATCH(ObjectUnpurgeableAPPLE); 1108 1109 _mesa_loopback_init_api_table(ctx, table); 1110 1111 return table; 1112 } 1113 1114 void 1115 _mesa_initialize_dispatch_tables(struct gl_context *ctx) 1116 { 1117 /* Do the code-generated setup of the exec table in api_exec.c. */ 1118 _mesa_initialize_exec_table(ctx); 1119 1120 if (ctx->Save) 1121 _mesa_initialize_save_table(ctx); 1122 } 1123 1124 /** 1125 * Initialize a struct gl_context struct (rendering context). 1126 * 1127 * This includes allocating all the other structs and arrays which hang off of 1128 * the context by pointers. 1129 * Note that the driver needs to pass in its dd_function_table here since 1130 * we need to at least call driverFunctions->NewTextureObject to create the 1131 * default texture objects. 1132 * 1133 * Called by _mesa_create_context(). 1134 * 1135 * Performs the imports and exports callback tables initialization, and 1136 * miscellaneous one-time initializations. If no shared context is supplied one 1137 * is allocated, and increase its reference count. Setups the GL API dispatch 1138 * tables. Initialize the TNL module. Sets the maximum Z buffer depth. 1139 * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables 1140 * for debug flags. 1141 * 1142 * \param ctx the context to initialize 1143 * \param api the GL API type to create the context for 1144 * \param visual describes the visual attributes for this context or NULL to 1145 * create a configless context 1146 * \param share_list points to context to share textures, display lists, 1147 * etc with, or NULL 1148 * \param driverFunctions table of device driver functions for this context 1149 * to use 1150 */ 1151 GLboolean 1152 _mesa_initialize_context(struct gl_context *ctx, 1153 gl_api api, 1154 const struct gl_config *visual, 1155 struct gl_context *share_list, 1156 const struct dd_function_table *driverFunctions) 1157 { 1158 struct gl_shared_state *shared; 1159 int i; 1160 1161 assert(driverFunctions->NewTextureObject); 1162 assert(driverFunctions->FreeTextureImageBuffer); 1163 1164 ctx->API = api; 1165 ctx->DrawBuffer = NULL; 1166 ctx->ReadBuffer = NULL; 1167 ctx->WinSysDrawBuffer = NULL; 1168 ctx->WinSysReadBuffer = NULL; 1169 1170 if (visual) { 1171 ctx->Visual = *visual; 1172 ctx->HasConfig = GL_TRUE; 1173 } 1174 else { 1175 memset(&ctx->Visual, 0, sizeof ctx->Visual); 1176 ctx->HasConfig = GL_FALSE; 1177 } 1178 1179 _mesa_override_gl_version(ctx); 1180 1181 /* misc one-time initializations */ 1182 one_time_init(ctx); 1183 1184 /* Plug in driver functions and context pointer here. 1185 * This is important because when we call alloc_shared_state() below 1186 * we'll call ctx->Driver.NewTextureObject() to create the default 1187 * textures. 1188 */ 1189 ctx->Driver = *driverFunctions; 1190 1191 if (share_list) { 1192 /* share state with another context */ 1193 shared = share_list->Shared; 1194 } 1195 else { 1196 /* allocate new, unshared state */ 1197 shared = _mesa_alloc_shared_state(ctx); 1198 if (!shared) 1199 return GL_FALSE; 1200 } 1201 1202 _mesa_reference_shared_state(ctx, &ctx->Shared, shared); 1203 1204 if (!init_attrib_groups( ctx )) 1205 goto fail; 1206 1207 /* setup the API dispatch tables with all nop functions */ 1208 ctx->OutsideBeginEnd = alloc_dispatch_table(); 1209 if (!ctx->OutsideBeginEnd) 1210 goto fail; 1211 ctx->Exec = ctx->OutsideBeginEnd; 1212 ctx->CurrentDispatch = ctx->OutsideBeginEnd; 1213 1214 ctx->FragmentProgram._MaintainTexEnvProgram 1215 = (getenv("MESA_TEX_PROG") != NULL); 1216 1217 ctx->VertexProgram._MaintainTnlProgram 1218 = (getenv("MESA_TNL_PROG") != NULL); 1219 if (ctx->VertexProgram._MaintainTnlProgram) { 1220 /* this is required... */ 1221 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE; 1222 } 1223 1224 /* Mesa core handles all the formats that mesa core knows about. 1225 * Drivers will want to override this list with just the formats 1226 * they can handle, and confirm that appropriate fallbacks exist in 1227 * _mesa_choose_tex_format(). 1228 */ 1229 memset(&ctx->TextureFormatSupported, GL_TRUE, 1230 sizeof(ctx->TextureFormatSupported)); 1231 1232 switch (ctx->API) { 1233 case API_OPENGL_COMPAT: 1234 ctx->BeginEnd = create_beginend_table(ctx); 1235 ctx->Save = alloc_dispatch_table(); 1236 if (!ctx->BeginEnd || !ctx->Save) 1237 goto fail; 1238 1239 /* fall-through */ 1240 case API_OPENGL_CORE: 1241 break; 1242 case API_OPENGLES: 1243 /** 1244 * GL_OES_texture_cube_map says 1245 * "Initially all texture generation modes are set to REFLECTION_MAP_OES" 1246 */ 1247 for (i = 0; i < MAX_TEXTURE_UNITS; i++) { 1248 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i]; 1249 texUnit->GenS.Mode = GL_REFLECTION_MAP_NV; 1250 texUnit->GenT.Mode = GL_REFLECTION_MAP_NV; 1251 texUnit->GenR.Mode = GL_REFLECTION_MAP_NV; 1252 texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV; 1253 texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV; 1254 texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV; 1255 } 1256 break; 1257 case API_OPENGLES2: 1258 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE; 1259 ctx->VertexProgram._MaintainTnlProgram = GL_TRUE; 1260 break; 1261 } 1262 1263 ctx->FirstTimeCurrent = GL_TRUE; 1264 1265 return GL_TRUE; 1266 1267 fail: 1268 _mesa_reference_shared_state(ctx, &ctx->Shared, NULL); 1269 free(ctx->BeginEnd); 1270 free(ctx->OutsideBeginEnd); 1271 free(ctx->Save); 1272 return GL_FALSE; 1273 } 1274 1275 1276 /** 1277 * Free the data associated with the given context. 1278 * 1279 * But doesn't free the struct gl_context struct itself. 1280 * 1281 * \sa _mesa_initialize_context() and init_attrib_groups(). 1282 */ 1283 void 1284 _mesa_free_context_data( struct gl_context *ctx ) 1285 { 1286 if (!_mesa_get_current_context()){ 1287 /* No current context, but we may need one in order to delete 1288 * texture objs, etc. So temporarily bind the context now. 1289 */ 1290 _mesa_make_current(ctx, NULL, NULL); 1291 } 1292 1293 /* unreference WinSysDraw/Read buffers */ 1294 _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL); 1295 _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL); 1296 _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL); 1297 _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL); 1298 1299 _mesa_reference_program(ctx, &ctx->VertexProgram.Current, NULL); 1300 _mesa_reference_program(ctx, &ctx->VertexProgram._Current, NULL); 1301 _mesa_reference_program(ctx, &ctx->VertexProgram._TnlProgram, NULL); 1302 1303 _mesa_reference_program(ctx, &ctx->TessCtrlProgram._Current, NULL); 1304 _mesa_reference_program(ctx, &ctx->TessEvalProgram._Current, NULL); 1305 _mesa_reference_program(ctx, &ctx->GeometryProgram._Current, NULL); 1306 1307 _mesa_reference_program(ctx, &ctx->FragmentProgram.Current, NULL); 1308 _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, NULL); 1309 _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL); 1310 1311 _mesa_reference_vao(ctx, &ctx->Array.VAO, NULL); 1312 _mesa_reference_vao(ctx, &ctx->Array.DefaultVAO, NULL); 1313 1314 _mesa_free_attrib_data(ctx); 1315 _mesa_free_buffer_objects(ctx); 1316 _mesa_free_eval_data( ctx ); 1317 _mesa_free_texture_data( ctx ); 1318 _mesa_free_matrix_data( ctx ); 1319 _mesa_free_pipeline_data(ctx); 1320 _mesa_free_program_data(ctx); 1321 _mesa_free_shader_state(ctx); 1322 _mesa_free_queryobj_data(ctx); 1323 _mesa_free_sync_data(ctx); 1324 _mesa_free_varray_data(ctx); 1325 _mesa_free_transform_feedback(ctx); 1326 _mesa_free_performance_monitors(ctx); 1327 1328 _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL); 1329 _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL); 1330 _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL); 1331 _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL); 1332 1333 /* free dispatch tables */ 1334 free(ctx->BeginEnd); 1335 free(ctx->OutsideBeginEnd); 1336 free(ctx->Save); 1337 free(ctx->ContextLost); 1338 1339 /* Shared context state (display lists, textures, etc) */ 1340 _mesa_reference_shared_state(ctx, &ctx->Shared, NULL); 1341 1342 /* needs to be after freeing shared state */ 1343 _mesa_free_display_list_data(ctx); 1344 1345 _mesa_free_errors_data(ctx); 1346 1347 free((void *)ctx->Extensions.String); 1348 1349 free(ctx->VersionString); 1350 1351 /* unbind the context if it's currently bound */ 1352 if (ctx == _mesa_get_current_context()) { 1353 _mesa_make_current(NULL, NULL, NULL); 1354 } 1355 } 1356 1357 1358 /** 1359 * Destroy a struct gl_context structure. 1360 * 1361 * \param ctx GL context. 1362 * 1363 * Calls _mesa_free_context_data() and frees the gl_context object itself. 1364 */ 1365 void 1366 _mesa_destroy_context( struct gl_context *ctx ) 1367 { 1368 if (ctx) { 1369 _mesa_free_context_data(ctx); 1370 free( (void *) ctx ); 1371 } 1372 } 1373 1374 1375 /** 1376 * Copy attribute groups from one context to another. 1377 * 1378 * \param src source context 1379 * \param dst destination context 1380 * \param mask bitwise OR of GL_*_BIT flags 1381 * 1382 * According to the bits specified in \p mask, copies the corresponding 1383 * attributes from \p src into \p dst. For many of the attributes a simple \c 1384 * memcpy is not enough due to the existence of internal pointers in their data 1385 * structures. 1386 */ 1387 void 1388 _mesa_copy_context( const struct gl_context *src, struct gl_context *dst, 1389 GLuint mask ) 1390 { 1391 if (mask & GL_ACCUM_BUFFER_BIT) { 1392 /* OK to memcpy */ 1393 dst->Accum = src->Accum; 1394 } 1395 if (mask & GL_COLOR_BUFFER_BIT) { 1396 /* OK to memcpy */ 1397 dst->Color = src->Color; 1398 } 1399 if (mask & GL_CURRENT_BIT) { 1400 /* OK to memcpy */ 1401 dst->Current = src->Current; 1402 } 1403 if (mask & GL_DEPTH_BUFFER_BIT) { 1404 /* OK to memcpy */ 1405 dst->Depth = src->Depth; 1406 } 1407 if (mask & GL_ENABLE_BIT) { 1408 /* no op */ 1409 } 1410 if (mask & GL_EVAL_BIT) { 1411 /* OK to memcpy */ 1412 dst->Eval = src->Eval; 1413 } 1414 if (mask & GL_FOG_BIT) { 1415 /* OK to memcpy */ 1416 dst->Fog = src->Fog; 1417 } 1418 if (mask & GL_HINT_BIT) { 1419 /* OK to memcpy */ 1420 dst->Hint = src->Hint; 1421 } 1422 if (mask & GL_LIGHTING_BIT) { 1423 /* OK to memcpy */ 1424 dst->Light = src->Light; 1425 } 1426 if (mask & GL_LINE_BIT) { 1427 /* OK to memcpy */ 1428 dst->Line = src->Line; 1429 } 1430 if (mask & GL_LIST_BIT) { 1431 /* OK to memcpy */ 1432 dst->List = src->List; 1433 } 1434 if (mask & GL_PIXEL_MODE_BIT) { 1435 /* OK to memcpy */ 1436 dst->Pixel = src->Pixel; 1437 } 1438 if (mask & GL_POINT_BIT) { 1439 /* OK to memcpy */ 1440 dst->Point = src->Point; 1441 } 1442 if (mask & GL_POLYGON_BIT) { 1443 /* OK to memcpy */ 1444 dst->Polygon = src->Polygon; 1445 } 1446 if (mask & GL_POLYGON_STIPPLE_BIT) { 1447 /* Use loop instead of memcpy due to problem with Portland Group's 1448 * C compiler. Reported by John Stone. 1449 */ 1450 GLuint i; 1451 for (i = 0; i < 32; i++) { 1452 dst->PolygonStipple[i] = src->PolygonStipple[i]; 1453 } 1454 } 1455 if (mask & GL_SCISSOR_BIT) { 1456 /* OK to memcpy */ 1457 dst->Scissor = src->Scissor; 1458 } 1459 if (mask & GL_STENCIL_BUFFER_BIT) { 1460 /* OK to memcpy */ 1461 dst->Stencil = src->Stencil; 1462 } 1463 if (mask & GL_TEXTURE_BIT) { 1464 /* Cannot memcpy because of pointers */ 1465 _mesa_copy_texture_state(src, dst); 1466 } 1467 if (mask & GL_TRANSFORM_BIT) { 1468 /* OK to memcpy */ 1469 dst->Transform = src->Transform; 1470 } 1471 if (mask & GL_VIEWPORT_BIT) { 1472 unsigned i; 1473 for (i = 0; i < src->Const.MaxViewports; i++) { 1474 /* OK to memcpy */ 1475 dst->ViewportArray[i] = src->ViewportArray[i]; 1476 } 1477 } 1478 1479 /* XXX FIXME: Call callbacks? 1480 */ 1481 dst->NewState = _NEW_ALL; 1482 dst->NewDriverState = ~0; 1483 } 1484 1485 1486 /** 1487 * Check if the given context can render into the given framebuffer 1488 * by checking visual attributes. 1489 * 1490 * \return GL_TRUE if compatible, GL_FALSE otherwise. 1491 */ 1492 static GLboolean 1493 check_compatible(const struct gl_context *ctx, 1494 const struct gl_framebuffer *buffer) 1495 { 1496 const struct gl_config *ctxvis = &ctx->Visual; 1497 const struct gl_config *bufvis = &buffer->Visual; 1498 1499 if (buffer == _mesa_get_incomplete_framebuffer()) 1500 return GL_TRUE; 1501 1502 #define check_component(foo) \ 1503 if (ctxvis->foo && bufvis->foo && \ 1504 ctxvis->foo != bufvis->foo) \ 1505 return GL_FALSE 1506 1507 check_component(redMask); 1508 check_component(greenMask); 1509 check_component(blueMask); 1510 check_component(depthBits); 1511 check_component(stencilBits); 1512 1513 #undef check_component 1514 1515 return GL_TRUE; 1516 } 1517 1518 1519 /** 1520 * Check if the viewport/scissor size has not yet been initialized. 1521 * Initialize the size if the given width and height are non-zero. 1522 */ 1523 void 1524 _mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height) 1525 { 1526 if (!ctx->ViewportInitialized && width > 0 && height > 0) { 1527 unsigned i; 1528 1529 /* Note: set flag here, before calling _mesa_set_viewport(), to prevent 1530 * potential infinite recursion. 1531 */ 1532 ctx->ViewportInitialized = GL_TRUE; 1533 1534 /* Note: ctx->Const.MaxViewports may not have been set by the driver 1535 * yet, so just initialize all of them. 1536 */ 1537 for (i = 0; i < MAX_VIEWPORTS; i++) { 1538 _mesa_set_viewport(ctx, i, 0, 0, width, height); 1539 _mesa_set_scissor(ctx, i, 0, 0, width, height); 1540 } 1541 } 1542 } 1543 1544 static void 1545 handle_first_current(struct gl_context *ctx) 1546 { 1547 if (ctx->Version == 0) { 1548 /* probably in the process of tearing down the context */ 1549 return; 1550 } 1551 1552 ctx->Extensions.String = _mesa_make_extension_string(ctx); 1553 1554 check_context_limits(ctx); 1555 1556 /* According to GL_MESA_configless_context the default value of 1557 * glDrawBuffers depends on the config of the first surface it is bound to. 1558 * For GLES it is always GL_BACK which has a magic interpretation */ 1559 if (!ctx->HasConfig && _mesa_is_desktop_gl(ctx)) { 1560 if (ctx->DrawBuffer != _mesa_get_incomplete_framebuffer()) { 1561 GLenum buffer; 1562 1563 if (ctx->DrawBuffer->Visual.doubleBufferMode) 1564 buffer = GL_BACK; 1565 else 1566 buffer = GL_FRONT; 1567 1568 _mesa_drawbuffers(ctx, ctx->DrawBuffer, 1, &buffer, 1569 NULL /* destMask */); 1570 } 1571 1572 if (ctx->ReadBuffer != _mesa_get_incomplete_framebuffer()) { 1573 gl_buffer_index bufferIndex; 1574 GLenum buffer; 1575 1576 if (ctx->ReadBuffer->Visual.doubleBufferMode) { 1577 buffer = GL_BACK; 1578 bufferIndex = BUFFER_BACK_LEFT; 1579 } 1580 else { 1581 buffer = GL_FRONT; 1582 bufferIndex = BUFFER_FRONT_LEFT; 1583 } 1584 1585 _mesa_readbuffer(ctx, ctx->ReadBuffer, buffer, bufferIndex); 1586 } 1587 } 1588 1589 /* We can use this to help debug user's problems. Tell them to set 1590 * the MESA_INFO env variable before running their app. Then the 1591 * first time each context is made current we'll print some useful 1592 * information. 1593 */ 1594 if (getenv("MESA_INFO")) { 1595 _mesa_print_info(ctx); 1596 } 1597 } 1598 1599 /** 1600 * Bind the given context to the given drawBuffer and readBuffer and 1601 * make it the current context for the calling thread. 1602 * We'll render into the drawBuffer and read pixels from the 1603 * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc). 1604 * 1605 * We check that the context's and framebuffer's visuals are compatible 1606 * and return immediately if they're not. 1607 * 1608 * \param newCtx the new GL context. If NULL then there will be no current GL 1609 * context. 1610 * \param drawBuffer the drawing framebuffer 1611 * \param readBuffer the reading framebuffer 1612 */ 1613 GLboolean 1614 _mesa_make_current( struct gl_context *newCtx, 1615 struct gl_framebuffer *drawBuffer, 1616 struct gl_framebuffer *readBuffer ) 1617 { 1618 GET_CURRENT_CONTEXT(curCtx); 1619 1620 if (MESA_VERBOSE & VERBOSE_API) 1621 _mesa_debug(newCtx, "_mesa_make_current()\n"); 1622 1623 /* Check that the context's and framebuffer's visuals are compatible. 1624 */ 1625 if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) { 1626 if (!check_compatible(newCtx, drawBuffer)) { 1627 _mesa_warning(newCtx, 1628 "MakeCurrent: incompatible visuals for context and drawbuffer"); 1629 return GL_FALSE; 1630 } 1631 } 1632 if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) { 1633 if (!check_compatible(newCtx, readBuffer)) { 1634 _mesa_warning(newCtx, 1635 "MakeCurrent: incompatible visuals for context and readbuffer"); 1636 return GL_FALSE; 1637 } 1638 } 1639 1640 if (curCtx && 1641 (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) && 1642 /* make sure this context is valid for flushing */ 1643 curCtx != newCtx && 1644 curCtx->Const.ContextReleaseBehavior == 1645 GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH) 1646 _mesa_flush(curCtx); 1647 1648 /* We used to call _glapi_check_multithread() here. Now do it in drivers */ 1649 _glapi_set_context((void *) newCtx); 1650 assert(_mesa_get_current_context() == newCtx); 1651 1652 if (!newCtx) { 1653 _glapi_set_dispatch(NULL); /* none current */ 1654 if (curCtx) { 1655 _mesa_reference_framebuffer(&curCtx->WinSysDrawBuffer, NULL); 1656 _mesa_reference_framebuffer(&curCtx->WinSysReadBuffer, NULL); 1657 } 1658 } 1659 else { 1660 _glapi_set_dispatch(newCtx->CurrentDispatch); 1661 1662 if (drawBuffer && readBuffer) { 1663 assert(_mesa_is_winsys_fbo(drawBuffer)); 1664 assert(_mesa_is_winsys_fbo(readBuffer)); 1665 _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer); 1666 _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer); 1667 1668 /* 1669 * Only set the context's Draw/ReadBuffer fields if they're NULL 1670 * or not bound to a user-created FBO. 1671 */ 1672 if (!newCtx->DrawBuffer || _mesa_is_winsys_fbo(newCtx->DrawBuffer)) { 1673 _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer); 1674 /* Update the FBO's list of drawbuffers/renderbuffers. 1675 * For winsys FBOs this comes from the GL state (which may have 1676 * changed since the last time this FBO was bound). 1677 */ 1678 _mesa_update_draw_buffers(newCtx); 1679 } 1680 if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) { 1681 _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer); 1682 /* In _mesa_initialize_window_framebuffer, for single-buffered 1683 * visuals, the ColorReadBuffer is set to be GL_FRONT, even with 1684 * GLES contexts. When calling read_buffer, we verify we are reading 1685 * from GL_BACK in is_legal_es3_readbuffer_enum. But the default is 1686 * incorrect, and certain dEQP tests check this. So fix it here. 1687 */ 1688 if (_mesa_is_gles(newCtx) && 1689 !newCtx->ReadBuffer->Visual.doubleBufferMode) 1690 if (newCtx->ReadBuffer->ColorReadBuffer == GL_FRONT) 1691 newCtx->ReadBuffer->ColorReadBuffer = GL_BACK; 1692 } 1693 1694 /* XXX only set this flag if we're really changing the draw/read 1695 * framebuffer bindings. 1696 */ 1697 newCtx->NewState |= _NEW_BUFFERS; 1698 1699 _mesa_check_init_viewport(newCtx, 1700 drawBuffer->Width, drawBuffer->Height); 1701 } 1702 1703 if (newCtx->FirstTimeCurrent) { 1704 handle_first_current(newCtx); 1705 newCtx->FirstTimeCurrent = GL_FALSE; 1706 } 1707 } 1708 1709 return GL_TRUE; 1710 } 1711 1712 1713 /** 1714 * Make context 'ctx' share the display lists, textures and programs 1715 * that are associated with 'ctxToShare'. 1716 * Any display lists, textures or programs associated with 'ctx' will 1717 * be deleted if nobody else is sharing them. 1718 */ 1719 GLboolean 1720 _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare) 1721 { 1722 if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) { 1723 struct gl_shared_state *oldShared = NULL; 1724 1725 /* save ref to old state to prevent it from being deleted immediately */ 1726 _mesa_reference_shared_state(ctx, &oldShared, ctx->Shared); 1727 1728 /* update ctx's Shared pointer */ 1729 _mesa_reference_shared_state(ctx, &ctx->Shared, ctxToShare->Shared); 1730 1731 update_default_objects(ctx); 1732 1733 /* release the old shared state */ 1734 _mesa_reference_shared_state(ctx, &oldShared, NULL); 1735 1736 return GL_TRUE; 1737 } 1738 else { 1739 return GL_FALSE; 1740 } 1741 } 1742 1743 1744 1745 /** 1746 * \return pointer to the current GL context for this thread. 1747 * 1748 * Calls _glapi_get_context(). This isn't the fastest way to get the current 1749 * context. If you need speed, see the #GET_CURRENT_CONTEXT macro in 1750 * context.h. 1751 */ 1752 struct gl_context * 1753 _mesa_get_current_context( void ) 1754 { 1755 return (struct gl_context *) _glapi_get_context(); 1756 } 1757 1758 1759 /** 1760 * Get context's current API dispatch table. 1761 * 1762 * It'll either be the immediate-mode execute dispatcher or the display list 1763 * compile dispatcher. 1764 * 1765 * \param ctx GL context. 1766 * 1767 * \return pointer to dispatch_table. 1768 * 1769 * Simply returns __struct gl_contextRec::CurrentDispatch. 1770 */ 1771 struct _glapi_table * 1772 _mesa_get_dispatch(struct gl_context *ctx) 1773 { 1774 return ctx->CurrentDispatch; 1775 } 1776 1777 /*@}*/ 1778 1779 1780 /**********************************************************************/ 1781 /** \name Miscellaneous functions */ 1782 /**********************************************************************/ 1783 /*@{*/ 1784 1785 /** 1786 * Record an error. 1787 * 1788 * \param ctx GL context. 1789 * \param error error code. 1790 * 1791 * Records the given error code and call the driver's dd_function_table::Error 1792 * function if defined. 1793 * 1794 * \sa 1795 * This is called via _mesa_error(). 1796 */ 1797 void 1798 _mesa_record_error(struct gl_context *ctx, GLenum error) 1799 { 1800 if (!ctx) 1801 return; 1802 1803 if (ctx->ErrorValue == GL_NO_ERROR) { 1804 ctx->ErrorValue = error; 1805 } 1806 } 1807 1808 1809 /** 1810 * Flush commands and wait for completion. 1811 */ 1812 void 1813 _mesa_finish(struct gl_context *ctx) 1814 { 1815 FLUSH_VERTICES( ctx, 0 ); 1816 FLUSH_CURRENT( ctx, 0 ); 1817 if (ctx->Driver.Finish) { 1818 ctx->Driver.Finish(ctx); 1819 } 1820 } 1821 1822 1823 /** 1824 * Flush commands. 1825 */ 1826 void 1827 _mesa_flush(struct gl_context *ctx) 1828 { 1829 FLUSH_VERTICES( ctx, 0 ); 1830 FLUSH_CURRENT( ctx, 0 ); 1831 if (ctx->Driver.Flush) { 1832 ctx->Driver.Flush(ctx); 1833 } 1834 } 1835 1836 1837 1838 /** 1839 * Execute glFinish(). 1840 * 1841 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the 1842 * dd_function_table::Finish driver callback, if not NULL. 1843 */ 1844 void GLAPIENTRY 1845 _mesa_Finish(void) 1846 { 1847 GET_CURRENT_CONTEXT(ctx); 1848 ASSERT_OUTSIDE_BEGIN_END(ctx); 1849 _mesa_finish(ctx); 1850 } 1851 1852 1853 /** 1854 * Execute glFlush(). 1855 * 1856 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the 1857 * dd_function_table::Flush driver callback, if not NULL. 1858 */ 1859 void GLAPIENTRY 1860 _mesa_Flush(void) 1861 { 1862 GET_CURRENT_CONTEXT(ctx); 1863 ASSERT_OUTSIDE_BEGIN_END(ctx); 1864 _mesa_flush(ctx); 1865 } 1866 1867 1868 1869 1870 /*@}*/ 1871
