context.c revision 021a525616bef2bafc8f60edc193b975ed2b0efa
1/* $Id: context.c,v 1.51 2000/03/27 17:54:17 brianp Exp $ */ 2 3/* 4 * Mesa 3-D graphics library 5 * Version: 3.3 6 * 7 * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. 8 * 9 * Permission is hereby granted, free of charge, to any person obtaining a 10 * copy of this software and associated documentation files (the "Software"), 11 * to deal in the Software without restriction, including without limitation 12 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 13 * and/or sell copies of the Software, and to permit persons to whom the 14 * Software is furnished to do so, subject to the following conditions: 15 * 16 * The above copyright notice and this permission notice shall be included 17 * in all copies or substantial portions of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 */ 26 27 28#ifdef PC_HEADER 29#include "all.h" 30#else 31#include "glheader.h" 32#include "accum.h" 33#include "alphabuf.h" 34#include "clip.h" 35#include "context.h" 36#include "cva.h" 37#include "depth.h" 38#include "dlist.h" 39#include "eval.h" 40#include "enums.h" 41#include "extensions.h" 42#include "fog.h" 43#include "get.h" 44#include "glapi.h" 45#include "glapinoop.h" 46#include "glthread.h" 47#include "hash.h" 48#include "light.h" 49#include "macros.h" 50#include "matrix.h" 51#include "mem.h" 52#include "mmath.h" 53#include "pb.h" 54#include "pipeline.h" 55#include "shade.h" 56#include "simple_list.h" 57#include "stencil.h" 58#include "stages.h" 59#include "state.h" 60#include "translate.h" 61#include "teximage.h" 62#include "texobj.h" 63#include "texstate.h" 64#include "texture.h" 65#include "types.h" 66#include "varray.h" 67#include "vb.h" 68#include "vbcull.h" 69#include "vbrender.h" 70#include "vbxform.h" 71#include "vertices.h" 72#include "xform.h" 73#endif 74 75 76 77/**********************************************************************/ 78/***** Context and Thread management *****/ 79/**********************************************************************/ 80 81 82#if !defined(THREADS) 83 84struct immediate *_mesa_CurrentInput = NULL; 85 86#endif 87 88 89 90 91/**********************************************************************/ 92/***** Profiling functions *****/ 93/**********************************************************************/ 94 95#ifdef PROFILE 96 97#include <sys/times.h> 98#include <sys/param.h> 99 100 101/* 102 * Return system time in seconds. 103 * NOTE: this implementation may not be very portable! 104 */ 105GLdouble gl_time( void ) 106{ 107 static GLdouble prev_time = 0.0; 108 static GLdouble time; 109 struct tms tm; 110 clock_t clk; 111 112 clk = times(&tm); 113 114#ifdef CLK_TCK 115 time = (double)clk / (double)CLK_TCK; 116#else 117 time = (double)clk / (double)HZ; 118#endif 119 120 if (time>prev_time) { 121 prev_time = time; 122 return time; 123 } 124 else { 125 return prev_time; 126 } 127} 128 129/* 130 * Reset the timing/profiling counters 131 */ 132static void init_timings( GLcontext *ctx ) 133{ 134 ctx->BeginEndCount = 0; 135 ctx->BeginEndTime = 0.0; 136 ctx->VertexCount = 0; 137 ctx->VertexTime = 0.0; 138 ctx->PointCount = 0; 139 ctx->PointTime = 0.0; 140 ctx->LineCount = 0; 141 ctx->LineTime = 0.0; 142 ctx->PolygonCount = 0; 143 ctx->PolygonTime = 0.0; 144 ctx->ClearCount = 0; 145 ctx->ClearTime = 0.0; 146 ctx->SwapCount = 0; 147 ctx->SwapTime = 0.0; 148} 149 150 151/* 152 * Print the accumulated timing/profiling data. 153 */ 154static void print_timings( GLcontext *ctx ) 155{ 156 GLdouble beginendrate; 157 GLdouble vertexrate; 158 GLdouble pointrate; 159 GLdouble linerate; 160 GLdouble polygonrate; 161 GLdouble overhead; 162 GLdouble clearrate; 163 GLdouble swaprate; 164 GLdouble avgvertices; 165 166 if (ctx->BeginEndTime>0.0) { 167 beginendrate = ctx->BeginEndCount / ctx->BeginEndTime; 168 } 169 else { 170 beginendrate = 0.0; 171 } 172 if (ctx->VertexTime>0.0) { 173 vertexrate = ctx->VertexCount / ctx->VertexTime; 174 } 175 else { 176 vertexrate = 0.0; 177 } 178 if (ctx->PointTime>0.0) { 179 pointrate = ctx->PointCount / ctx->PointTime; 180 } 181 else { 182 pointrate = 0.0; 183 } 184 if (ctx->LineTime>0.0) { 185 linerate = ctx->LineCount / ctx->LineTime; 186 } 187 else { 188 linerate = 0.0; 189 } 190 if (ctx->PolygonTime>0.0) { 191 polygonrate = ctx->PolygonCount / ctx->PolygonTime; 192 } 193 else { 194 polygonrate = 0.0; 195 } 196 if (ctx->ClearTime>0.0) { 197 clearrate = ctx->ClearCount / ctx->ClearTime; 198 } 199 else { 200 clearrate = 0.0; 201 } 202 if (ctx->SwapTime>0.0) { 203 swaprate = ctx->SwapCount / ctx->SwapTime; 204 } 205 else { 206 swaprate = 0.0; 207 } 208 209 if (ctx->BeginEndCount>0) { 210 avgvertices = (GLdouble) ctx->VertexCount / (GLdouble) ctx->BeginEndCount; 211 } 212 else { 213 avgvertices = 0.0; 214 } 215 216 overhead = ctx->BeginEndTime - ctx->VertexTime - ctx->PointTime 217 - ctx->LineTime - ctx->PolygonTime; 218 219 220 printf(" Count Time (s) Rate (/s) \n"); 221 printf("--------------------------------------------------------\n"); 222 printf("glBegin/glEnd %7d %8.3f %10.3f\n", 223 ctx->BeginEndCount, ctx->BeginEndTime, beginendrate); 224 printf(" vertexes transformed %7d %8.3f %10.3f\n", 225 ctx->VertexCount, ctx->VertexTime, vertexrate ); 226 printf(" points rasterized %7d %8.3f %10.3f\n", 227 ctx->PointCount, ctx->PointTime, pointrate ); 228 printf(" lines rasterized %7d %8.3f %10.3f\n", 229 ctx->LineCount, ctx->LineTime, linerate ); 230 printf(" polygons rasterized %7d %8.3f %10.3f\n", 231 ctx->PolygonCount, ctx->PolygonTime, polygonrate ); 232 printf(" overhead %8.3f\n", overhead ); 233 printf("glClear %7d %8.3f %10.3f\n", 234 ctx->ClearCount, ctx->ClearTime, clearrate ); 235 printf("SwapBuffers %7d %8.3f %10.3f\n", 236 ctx->SwapCount, ctx->SwapTime, swaprate ); 237 printf("\n"); 238 239 printf("Average number of vertices per begin/end: %8.3f\n", avgvertices ); 240} 241#endif 242 243 244 245 246 247/**********************************************************************/ 248/***** GL Visual allocation/destruction *****/ 249/**********************************************************************/ 250 251 252/* 253 * Allocate a new GLvisual object. 254 * Input: rgbFlag - GL_TRUE=RGB(A) mode, GL_FALSE=Color Index mode 255 * alphaFlag - alloc software alpha buffers? 256 * dbFlag - double buffering? 257 * stereoFlag - stereo buffer? 258 * depthBits - requested bits per depth buffer value 259 * Any value in [0, 32] is acceptable but the actual 260 * depth type will be GLushort or GLuint as needed. 261 * stencilBits - requested minimum bits per stencil buffer value 262 * accumBits - requested minimum bits per accum buffer component 263 * indexBits - number of bits per pixel if rgbFlag==GL_FALSE 264 * red/green/blue/alphaBits - number of bits per color component 265 * in frame buffer for RGB(A) mode. 266 * We always use 8 in core Mesa though. 267 * Return: pointer to new GLvisual or NULL if requested parameters can't 268 * be met. 269 */ 270GLvisual *gl_create_visual( GLboolean rgbFlag, 271 GLboolean alphaFlag, 272 GLboolean dbFlag, 273 GLboolean stereoFlag, 274 GLint depthBits, 275 GLint stencilBits, 276 GLint accumBits, 277 GLint indexBits, 278 GLint redBits, 279 GLint greenBits, 280 GLint blueBits, 281 GLint alphaBits ) 282{ 283 GLvisual *vis; 284 285 /* This is to catch bad values from device drivers not updated for 286 * Mesa 3.3. Some device drivers just passed 1. That's a REALLY 287 * bad value now (a 1-bit depth buffer!?!). 288 */ 289 assert(depthBits == 0 || depthBits > 1); 290 291 if (depthBits < 0 || depthBits > 32) { 292 return NULL; 293 } 294 if (stencilBits < 0 || stencilBits > (GLint) (8 * sizeof(GLstencil))) { 295 return NULL; 296 } 297 if (accumBits < 0 || accumBits > (GLint) (8 * sizeof(GLaccum))) { 298 return NULL; 299 } 300 301 vis = (GLvisual *) CALLOC( sizeof(GLvisual) ); 302 if (!vis) { 303 return NULL; 304 } 305 306 vis->RGBAflag = rgbFlag; 307 vis->DBflag = dbFlag; 308 vis->StereoFlag = stereoFlag; 309 vis->RedBits = redBits; 310 vis->GreenBits = greenBits; 311 vis->BlueBits = blueBits; 312 vis->AlphaBits = alphaFlag ? (8 * sizeof(GLubyte)) : alphaBits; 313 314 vis->IndexBits = indexBits; 315 vis->DepthBits = depthBits; 316 vis->AccumBits = (accumBits > 0) ? (8 * sizeof(GLaccum)) : 0; 317 vis->StencilBits = (stencilBits > 0) ? (8 * sizeof(GLstencil)) : 0; 318 319 vis->SoftwareAlpha = alphaFlag; 320 321 if (depthBits == 0) { 322 /* Special case. Even if we don't have a depth buffer we need 323 * good values for DepthMax for Z vertex transformation purposes. 324 */ 325 vis->DepthMax = 1; 326 vis->DepthMaxF = 1.0F; 327 } 328 else { 329 vis->DepthMax = (1 << depthBits) - 1; 330 vis->DepthMaxF = (GLfloat) vis->DepthMax; 331 } 332 333 return vis; 334} 335 336 337 338void gl_destroy_visual( GLvisual *vis ) 339{ 340 FREE( vis ); 341} 342 343 344 345/**********************************************************************/ 346/***** GL Framebuffer allocation/destruction *****/ 347/**********************************************************************/ 348 349 350/* 351 * Create a new framebuffer. A GLframebuffer is a struct which 352 * encapsulates the depth, stencil and accum buffers and related 353 * parameters. 354 * Input: visual - a GLvisual pointer 355 * softwareDepth - create/use a software depth buffer? 356 * softwareStencil - create/use a software stencil buffer? 357 * softwareAccum - create/use a software accum buffer? 358 * softwareAlpha - create/use a software alpha buffer? 359 360 * Return: pointer to new GLframebuffer struct or NULL if error. 361 */ 362GLframebuffer *gl_create_framebuffer( GLvisual *visual, 363 GLboolean softwareDepth, 364 GLboolean softwareStencil, 365 GLboolean softwareAccum, 366 GLboolean softwareAlpha ) 367{ 368 GLframebuffer *buffer; 369 370 buffer = CALLOC_STRUCT(gl_frame_buffer); 371 if (!buffer) { 372 return NULL; 373 } 374 375 /* sanity checks */ 376 if (softwareDepth ) { 377 assert(visual->DepthBits > 0); 378 } 379 if (softwareStencil) { 380 assert(visual->StencilBits > 0); 381 } 382 if (softwareAccum) { 383 assert(visual->RGBAflag); 384 assert(visual->AccumBits > 0); 385 } 386 if (softwareAlpha) { 387 assert(visual->RGBAflag); 388 assert(visual->AlphaBits > 0); 389 } 390 391 buffer->Visual = visual; 392 buffer->UseSoftwareDepthBuffer = softwareDepth; 393 buffer->UseSoftwareStencilBuffer = softwareStencil; 394 buffer->UseSoftwareAccumBuffer = softwareAccum; 395 buffer->UseSoftwareAlphaBuffers = softwareAlpha; 396 397 return buffer; 398} 399 400 401 402/* 403 * Free a framebuffer struct and its buffers. 404 */ 405void gl_destroy_framebuffer( GLframebuffer *buffer ) 406{ 407 if (buffer) { 408 if (buffer->DepthBuffer) { 409 FREE( buffer->DepthBuffer ); 410 } 411 if (buffer->Accum) { 412 FREE( buffer->Accum ); 413 } 414 if (buffer->Stencil) { 415 FREE( buffer->Stencil ); 416 } 417 if (buffer->FrontLeftAlpha) { 418 FREE( buffer->FrontLeftAlpha ); 419 } 420 if (buffer->BackLeftAlpha) { 421 FREE( buffer->BackLeftAlpha ); 422 } 423 if (buffer->FrontRightAlpha) { 424 FREE( buffer->FrontRightAlpha ); 425 } 426 if (buffer->BackRightAlpha) { 427 FREE( buffer->BackRightAlpha ); 428 } 429 FREE(buffer); 430 } 431} 432 433 434 435/**********************************************************************/ 436/***** Context allocation, initialization, destroying *****/ 437/**********************************************************************/ 438 439 440_glthread_DECLARE_STATIC_MUTEX(OneTimeLock); 441 442 443/* 444 * This function just calls all the various one-time-init functions in Mesa. 445 */ 446static void one_time_init( void ) 447{ 448 static GLboolean alreadyCalled = GL_FALSE; 449 _glthread_LOCK_MUTEX(OneTimeLock); 450 if (!alreadyCalled) { 451 /* do some implementation tests */ 452 assert( sizeof(GLbyte) == 1 ); 453 assert( sizeof(GLshort) >= 2 ); 454 assert( sizeof(GLint) >= 4 ); 455 assert( sizeof(GLubyte) == 1 ); 456 assert( sizeof(GLushort) >= 2 ); 457 assert( sizeof(GLuint) >= 4 ); 458 459 gl_init_clip(); 460 gl_init_eval(); 461 _mesa_init_fog(); 462 _mesa_init_math(); 463 gl_init_lists(); 464 gl_init_shade(); 465 gl_init_texture(); 466 gl_init_transformation(); 467 gl_init_translate(); 468 gl_init_vbrender(); 469 gl_init_vbxform(); 470 gl_init_vertices(); 471 472 if (getenv("MESA_DEBUG")) { 473 _glapi_noop_enable_warnings(GL_TRUE); 474 } 475 else { 476 _glapi_noop_enable_warnings(GL_FALSE); 477 } 478 479#if defined(DEBUG) && defined(__DATE__) && defined(__TIME__) 480 fprintf(stderr, "Mesa DEBUG build %s %s\n", __DATE__, __TIME__); 481#endif 482 483 alreadyCalled = GL_TRUE; 484 } 485 _glthread_UNLOCK_MUTEX(OneTimeLock); 486} 487 488 489 490/* 491 * Allocate and initialize a shared context state structure. 492 */ 493static struct gl_shared_state *alloc_shared_state( void ) 494{ 495 GLuint d; 496 struct gl_shared_state *ss; 497 GLboolean outOfMemory; 498 499 ss = CALLOC_STRUCT(gl_shared_state); 500 if (!ss) 501 return NULL; 502 503 ss->DisplayList = _mesa_NewHashTable(); 504 505 ss->TexObjects = _mesa_NewHashTable(); 506 507 /* Default Texture objects */ 508 outOfMemory = GL_FALSE; 509 for (d = 1 ; d <= 3 ; d++) { 510 ss->DefaultD[d] = gl_alloc_texture_object(ss, 0, d); 511 if (!ss->DefaultD[d]) { 512 outOfMemory = GL_TRUE; 513 break; 514 } 515 ss->DefaultD[d]->RefCount++; /* don't free if not in use */ 516 } 517 518 if (!ss->DisplayList || !ss->TexObjects || outOfMemory) { 519 /* Ran out of memory at some point. Free everything and return NULL */ 520 if (ss->DisplayList) 521 _mesa_DeleteHashTable(ss->DisplayList); 522 if (ss->TexObjects) 523 _mesa_DeleteHashTable(ss->TexObjects); 524 if (ss->DefaultD[1]) 525 gl_free_texture_object(ss, ss->DefaultD[1]); 526 if (ss->DefaultD[2]) 527 gl_free_texture_object(ss, ss->DefaultD[2]); 528 if (ss->DefaultD[3]) 529 gl_free_texture_object(ss, ss->DefaultD[3]); 530 FREE(ss); 531 return NULL; 532 } 533 else { 534 return ss; 535 } 536} 537 538 539/* 540 * Deallocate a shared state context and all children structures. 541 */ 542static void free_shared_state( GLcontext *ctx, struct gl_shared_state *ss ) 543{ 544 /* Free display lists */ 545 while (1) { 546 GLuint list = _mesa_HashFirstEntry(ss->DisplayList); 547 if (list) { 548 gl_destroy_list(ctx, list); 549 } 550 else { 551 break; 552 } 553 } 554 _mesa_DeleteHashTable(ss->DisplayList); 555 556 /* Free texture objects */ 557 while (ss->TexObjectList) 558 { 559 if (ctx->Driver.DeleteTexture) 560 (*ctx->Driver.DeleteTexture)( ctx, ss->TexObjectList ); 561 /* this function removes from linked list too! */ 562 gl_free_texture_object(ss, ss->TexObjectList); 563 } 564 _mesa_DeleteHashTable(ss->TexObjects); 565 566 FREE(ss); 567} 568 569 570 571/* 572 * Initialize the nth light. Note that the defaults for light 0 are 573 * different than the other lights. 574 */ 575static void init_light( struct gl_light *l, GLuint n ) 576{ 577 make_empty_list( l ); 578 579 ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 ); 580 if (n==0) { 581 ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 ); 582 ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 ); 583 } 584 else { 585 ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 ); 586 ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 ); 587 } 588 ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 ); 589 ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 ); 590 l->SpotExponent = 0.0; 591 gl_compute_spot_exp_table( l ); 592 l->SpotCutoff = 180.0; 593 l->CosCutoff = 0.0; /* KW: -ve values not admitted */ 594 l->ConstantAttenuation = 1.0; 595 l->LinearAttenuation = 0.0; 596 l->QuadraticAttenuation = 0.0; 597 l->Enabled = GL_FALSE; 598} 599 600 601 602static void init_lightmodel( struct gl_lightmodel *lm ) 603{ 604 ASSIGN_4V( lm->Ambient, 0.2, 0.2, 0.2, 1.0 ); 605 lm->LocalViewer = GL_FALSE; 606 lm->TwoSide = GL_FALSE; 607 lm->ColorControl = GL_SINGLE_COLOR; 608} 609 610 611static void init_material( struct gl_material *m ) 612{ 613 ASSIGN_4V( m->Ambient, 0.2, 0.2, 0.2, 1.0 ); 614 ASSIGN_4V( m->Diffuse, 0.8, 0.8, 0.8, 1.0 ); 615 ASSIGN_4V( m->Specular, 0.0, 0.0, 0.0, 1.0 ); 616 ASSIGN_4V( m->Emission, 0.0, 0.0, 0.0, 1.0 ); 617 m->Shininess = 0.0; 618 m->AmbientIndex = 0; 619 m->DiffuseIndex = 1; 620 m->SpecularIndex = 1; 621} 622 623 624 625static void init_texture_unit( GLcontext *ctx, GLuint unit ) 626{ 627 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; 628 629 texUnit->EnvMode = GL_MODULATE; 630 ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 ); 631 texUnit->TexGenEnabled = 0; 632 texUnit->GenModeS = GL_EYE_LINEAR; 633 texUnit->GenModeT = GL_EYE_LINEAR; 634 texUnit->GenModeR = GL_EYE_LINEAR; 635 texUnit->GenModeQ = GL_EYE_LINEAR; 636 /* Yes, these plane coefficients are correct! */ 637 ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 ); 638 ASSIGN_4V( texUnit->ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 ); 639 ASSIGN_4V( texUnit->ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 ); 640 ASSIGN_4V( texUnit->ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 ); 641 ASSIGN_4V( texUnit->EyePlaneS, 1.0, 0.0, 0.0, 0.0 ); 642 ASSIGN_4V( texUnit->EyePlaneT, 0.0, 1.0, 0.0, 0.0 ); 643 ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 ); 644 ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 ); 645 646 texUnit->CurrentD[1] = ctx->Shared->DefaultD[1]; 647 texUnit->CurrentD[2] = ctx->Shared->DefaultD[2]; 648 texUnit->CurrentD[3] = ctx->Shared->DefaultD[3]; 649} 650 651 652static void init_fallback_arrays( GLcontext *ctx ) 653{ 654 struct gl_client_array *cl; 655 GLuint i; 656 657 cl = &ctx->Fallback.Normal; 658 cl->Size = 3; 659 cl->Type = GL_FLOAT; 660 cl->Stride = 0; 661 cl->StrideB = 0; 662 cl->Ptr = (void *) ctx->Current.Normal; 663 cl->Enabled = 1; 664 665 cl = &ctx->Fallback.Color; 666 cl->Size = 4; 667 cl->Type = GL_UNSIGNED_BYTE; 668 cl->Stride = 0; 669 cl->StrideB = 0; 670 cl->Ptr = (void *) ctx->Current.ByteColor; 671 cl->Enabled = 1; 672 673 cl = &ctx->Fallback.Index; 674 cl->Size = 1; 675 cl->Type = GL_UNSIGNED_INT; 676 cl->Stride = 0; 677 cl->StrideB = 0; 678 cl->Ptr = (void *) &ctx->Current.Index; 679 cl->Enabled = 1; 680 681 for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) { 682 cl = &ctx->Fallback.TexCoord[i]; 683 cl->Size = 4; 684 cl->Type = GL_FLOAT; 685 cl->Stride = 0; 686 cl->StrideB = 0; 687 cl->Ptr = (void *) ctx->Current.Texcoord[i]; 688 cl->Enabled = 1; 689 } 690 691 cl = &ctx->Fallback.EdgeFlag; 692 cl->Size = 1; 693 cl->Type = GL_UNSIGNED_BYTE; 694 cl->Stride = 0; 695 cl->StrideB = 0; 696 cl->Ptr = (void *) &ctx->Current.EdgeFlag; 697 cl->Enabled = 1; 698} 699 700 701/* Initialize a 1-D evaluator map */ 702static void init_1d_map( struct gl_1d_map *map, int n, const float *initial ) 703{ 704 map->Order = 1; 705 map->u1 = 0.0; 706 map->u2 = 1.0; 707 map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat)); 708 if (map->Points) { 709 GLint i; 710 for (i=0;i<n;i++) 711 map->Points[i] = initial[i]; 712 } 713} 714 715 716/* Initialize a 2-D evaluator map */ 717static void init_2d_map( struct gl_2d_map *map, int n, const float *initial ) 718{ 719 map->Uorder = 1; 720 map->Vorder = 1; 721 map->u1 = 0.0; 722 map->u2 = 1.0; 723 map->v1 = 0.0; 724 map->v2 = 1.0; 725 map->Points = (GLfloat *) MALLOC(n * sizeof(GLfloat)); 726 if (map->Points) { 727 GLint i; 728 for (i=0;i<n;i++) 729 map->Points[i] = initial[i]; 730 } 731} 732 733 734static void init_color_table( struct gl_color_table *p ) 735{ 736 p->Table[0] = 255; 737 p->Table[1] = 255; 738 p->Table[2] = 255; 739 p->Table[3] = 255; 740 p->Size = 1; 741 p->IntFormat = GL_RGBA; 742 p->Format = GL_RGBA; 743} 744 745 746/* 747 * Initialize the attribute groups in a GLcontext. 748 */ 749static void init_attrib_groups( GLcontext *ctx ) 750{ 751 GLuint i, j; 752 753 assert(ctx); 754 755 /* Constants, may be overriden by device drivers */ 756 ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS; 757 ctx->Const.MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1); 758 ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS; 759 ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE; 760 ctx->Const.SubPixelBits = SUB_PIXEL_BITS; 761 ctx->Const.MinPointSize = MIN_POINT_SIZE; 762 ctx->Const.MaxPointSize = MAX_POINT_SIZE; 763 ctx->Const.MinPointSizeAA = MIN_POINT_SIZE; 764 ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE; 765 ctx->Const.PointSizeGranularity = POINT_SIZE_GRANULARITY; 766 ctx->Const.MinLineWidth = MIN_LINE_WIDTH; 767 ctx->Const.MaxLineWidth = MAX_LINE_WIDTH; 768 ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH; 769 ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH; 770 ctx->Const.LineWidthGranularity = LINE_WIDTH_GRANULARITY; 771 ctx->Const.NumAuxBuffers = NUM_AUX_BUFFERS; 772 773 /* Modelview matrix */ 774 gl_matrix_ctr( &ctx->ModelView ); 775 gl_matrix_alloc_inv( &ctx->ModelView ); 776 777 ctx->ModelViewStackDepth = 0; 778 for (i = 0; i < MAX_MODELVIEW_STACK_DEPTH - 1; i++) { 779 gl_matrix_ctr( &ctx->ModelViewStack[i] ); 780 gl_matrix_alloc_inv( &ctx->ModelViewStack[i] ); 781 } 782 783 /* Projection matrix - need inv for user clipping in clip space*/ 784 gl_matrix_ctr( &ctx->ProjectionMatrix ); 785 gl_matrix_alloc_inv( &ctx->ProjectionMatrix ); 786 787 gl_matrix_ctr( &ctx->ModelProjectMatrix ); 788 gl_matrix_ctr( &ctx->ModelProjectWinMatrix ); 789 ctx->ModelProjectWinMatrixUptodate = GL_FALSE; 790 791 ctx->ProjectionStackDepth = 0; 792 ctx->NearFarStack[0][0] = 1.0; /* These values seem weird by make */ 793 ctx->NearFarStack[0][1] = 0.0; /* sense mathematically. */ 794 795 for (i = 0; i < MAX_PROJECTION_STACK_DEPTH - 1; i++) { 796 gl_matrix_ctr( &ctx->ProjectionStack[i] ); 797 gl_matrix_alloc_inv( &ctx->ProjectionStack[i] ); 798 } 799 800 /* Texture matrix */ 801 for (i=0; i<MAX_TEXTURE_UNITS; i++) { 802 gl_matrix_ctr( &ctx->TextureMatrix[i] ); 803 ctx->TextureStackDepth[i] = 0; 804 for (j = 0; j < MAX_TEXTURE_STACK_DEPTH - 1; j++) { 805 ctx->TextureStack[i][j].inv = 0; 806 } 807 } 808 809 /* Accumulate buffer group */ 810 ASSIGN_4V( ctx->Accum.ClearColor, 0.0, 0.0, 0.0, 0.0 ); 811 812 /* Color buffer group */ 813 ctx->Color.IndexMask = 0xffffffff; 814 ctx->Color.ColorMask[0] = 0xff; 815 ctx->Color.ColorMask[1] = 0xff; 816 ctx->Color.ColorMask[2] = 0xff; 817 ctx->Color.ColorMask[3] = 0xff; 818 ctx->Color.SWmasking = GL_FALSE; 819 ctx->Color.ClearIndex = 0; 820 ASSIGN_4V( ctx->Color.ClearColor, 0.0, 0.0, 0.0, 0.0 ); 821 ctx->Color.DrawBuffer = GL_FRONT; 822 ctx->Color.AlphaEnabled = GL_FALSE; 823 ctx->Color.AlphaFunc = GL_ALWAYS; 824 ctx->Color.AlphaRef = 0; 825 ctx->Color.BlendEnabled = GL_FALSE; 826 ctx->Color.BlendSrcRGB = GL_ONE; 827 ctx->Color.BlendDstRGB = GL_ZERO; 828 ctx->Color.BlendSrcA = GL_ONE; 829 ctx->Color.BlendDstA = GL_ZERO; 830 ctx->Color.BlendEquation = GL_FUNC_ADD_EXT; 831 ctx->Color.BlendFunc = NULL; /* this pointer set only when needed */ 832 ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 ); 833 ctx->Color.IndexLogicOpEnabled = GL_FALSE; 834 ctx->Color.ColorLogicOpEnabled = GL_FALSE; 835 ctx->Color.SWLogicOpEnabled = GL_FALSE; 836 ctx->Color.LogicOp = GL_COPY; 837 ctx->Color.DitherFlag = GL_TRUE; 838 ctx->Color.MultiDrawBuffer = GL_FALSE; 839 840 /* Current group */ 841 ASSIGN_4V( ctx->Current.ByteColor, 255, 255, 255, 255); 842 ctx->Current.Index = 1; 843 for (i=0; i<MAX_TEXTURE_UNITS; i++) 844 ASSIGN_4V( ctx->Current.Texcoord[i], 0.0, 0.0, 0.0, 1.0 ); 845 ASSIGN_4V( ctx->Current.RasterPos, 0.0, 0.0, 0.0, 1.0 ); 846 ctx->Current.RasterDistance = 0.0; 847 ASSIGN_4V( ctx->Current.RasterColor, 1.0, 1.0, 1.0, 1.0 ); 848 ctx->Current.RasterIndex = 1; 849 for (i=0; i<MAX_TEXTURE_UNITS; i++) 850 ASSIGN_4V( ctx->Current.RasterMultiTexCoord[i], 0.0, 0.0, 0.0, 1.0 ); 851 ctx->Current.RasterTexCoord = ctx->Current.RasterMultiTexCoord[0]; 852 ctx->Current.RasterPosValid = GL_TRUE; 853 ctx->Current.EdgeFlag = GL_TRUE; 854 ASSIGN_3V( ctx->Current.Normal, 0.0, 0.0, 1.0 ); 855 ctx->Current.Primitive = (GLenum) (GL_POLYGON + 1); 856 857 ctx->Current.Flag = (VERT_NORM|VERT_INDEX|VERT_RGBA|VERT_EDGE| 858 VERT_TEX0_1|VERT_TEX1_1|VERT_MATERIAL); 859 860 init_fallback_arrays( ctx ); 861 862 /* Depth buffer group */ 863 ctx->Depth.Test = GL_FALSE; 864 ctx->Depth.Clear = 1.0; 865 ctx->Depth.Func = GL_LESS; 866 ctx->Depth.Mask = GL_TRUE; 867 ctx->Depth.OcclusionTest = GL_FALSE; 868 869 /* Evaluators group */ 870 ctx->Eval.Map1Color4 = GL_FALSE; 871 ctx->Eval.Map1Index = GL_FALSE; 872 ctx->Eval.Map1Normal = GL_FALSE; 873 ctx->Eval.Map1TextureCoord1 = GL_FALSE; 874 ctx->Eval.Map1TextureCoord2 = GL_FALSE; 875 ctx->Eval.Map1TextureCoord3 = GL_FALSE; 876 ctx->Eval.Map1TextureCoord4 = GL_FALSE; 877 ctx->Eval.Map1Vertex3 = GL_FALSE; 878 ctx->Eval.Map1Vertex4 = GL_FALSE; 879 ctx->Eval.Map2Color4 = GL_FALSE; 880 ctx->Eval.Map2Index = GL_FALSE; 881 ctx->Eval.Map2Normal = GL_FALSE; 882 ctx->Eval.Map2TextureCoord1 = GL_FALSE; 883 ctx->Eval.Map2TextureCoord2 = GL_FALSE; 884 ctx->Eval.Map2TextureCoord3 = GL_FALSE; 885 ctx->Eval.Map2TextureCoord4 = GL_FALSE; 886 ctx->Eval.Map2Vertex3 = GL_FALSE; 887 ctx->Eval.Map2Vertex4 = GL_FALSE; 888 ctx->Eval.AutoNormal = GL_FALSE; 889 ctx->Eval.MapGrid1un = 1; 890 ctx->Eval.MapGrid1u1 = 0.0; 891 ctx->Eval.MapGrid1u2 = 1.0; 892 ctx->Eval.MapGrid2un = 1; 893 ctx->Eval.MapGrid2vn = 1; 894 ctx->Eval.MapGrid2u1 = 0.0; 895 ctx->Eval.MapGrid2u2 = 1.0; 896 ctx->Eval.MapGrid2v1 = 0.0; 897 ctx->Eval.MapGrid2v2 = 1.0; 898 899 /* Evaluator data */ 900 { 901 static GLfloat vertex[4] = { 0.0, 0.0, 0.0, 1.0 }; 902 static GLfloat normal[3] = { 0.0, 0.0, 1.0 }; 903 static GLfloat index[1] = { 1.0 }; 904 static GLfloat color[4] = { 1.0, 1.0, 1.0, 1.0 }; 905 static GLfloat texcoord[4] = { 0.0, 0.0, 0.0, 1.0 }; 906 907 init_1d_map( &ctx->EvalMap.Map1Vertex3, 3, vertex ); 908 init_1d_map( &ctx->EvalMap.Map1Vertex4, 4, vertex ); 909 init_1d_map( &ctx->EvalMap.Map1Index, 1, index ); 910 init_1d_map( &ctx->EvalMap.Map1Color4, 4, color ); 911 init_1d_map( &ctx->EvalMap.Map1Normal, 3, normal ); 912 init_1d_map( &ctx->EvalMap.Map1Texture1, 1, texcoord ); 913 init_1d_map( &ctx->EvalMap.Map1Texture2, 2, texcoord ); 914 init_1d_map( &ctx->EvalMap.Map1Texture3, 3, texcoord ); 915 init_1d_map( &ctx->EvalMap.Map1Texture4, 4, texcoord ); 916 917 init_2d_map( &ctx->EvalMap.Map2Vertex3, 3, vertex ); 918 init_2d_map( &ctx->EvalMap.Map2Vertex4, 4, vertex ); 919 init_2d_map( &ctx->EvalMap.Map2Index, 1, index ); 920 init_2d_map( &ctx->EvalMap.Map2Color4, 4, color ); 921 init_2d_map( &ctx->EvalMap.Map2Normal, 3, normal ); 922 init_2d_map( &ctx->EvalMap.Map2Texture1, 1, texcoord ); 923 init_2d_map( &ctx->EvalMap.Map2Texture2, 2, texcoord ); 924 init_2d_map( &ctx->EvalMap.Map2Texture3, 3, texcoord ); 925 init_2d_map( &ctx->EvalMap.Map2Texture4, 4, texcoord ); 926 } 927 928 /* Fog group */ 929 ctx->Fog.Enabled = GL_FALSE; 930 ctx->Fog.Mode = GL_EXP; 931 ASSIGN_4V( ctx->Fog.Color, 0.0, 0.0, 0.0, 0.0 ); 932 ctx->Fog.Index = 0.0; 933 ctx->Fog.Density = 1.0; 934 ctx->Fog.Start = 0.0; 935 ctx->Fog.End = 1.0; 936 937 /* Hint group */ 938 ctx->Hint.PerspectiveCorrection = GL_DONT_CARE; 939 ctx->Hint.PointSmooth = GL_DONT_CARE; 940 ctx->Hint.LineSmooth = GL_DONT_CARE; 941 ctx->Hint.PolygonSmooth = GL_DONT_CARE; 942 ctx->Hint.Fog = GL_DONT_CARE; 943 944 ctx->Hint.AllowDrawWin = GL_TRUE; 945 ctx->Hint.AllowDrawSpn = GL_TRUE; 946 ctx->Hint.AllowDrawMem = GL_TRUE; 947 ctx->Hint.StrictLighting = GL_TRUE; 948 949 /* Pipeline */ 950 gl_pipeline_init( ctx ); 951 gl_cva_init( ctx ); 952 953 /* Extensions */ 954 gl_extensions_ctr( ctx ); 955 956 ctx->AllowVertexCull = CLIP_CULLED_BIT; 957 958 /* Lighting group */ 959 for (i=0;i<MAX_LIGHTS;i++) { 960 init_light( &ctx->Light.Light[i], i ); 961 } 962 make_empty_list( &ctx->Light.EnabledList ); 963 964 init_lightmodel( &ctx->Light.Model ); 965 init_material( &ctx->Light.Material[0] ); 966 init_material( &ctx->Light.Material[1] ); 967 ctx->Light.ShadeModel = GL_SMOOTH; 968 ctx->Light.Enabled = GL_FALSE; 969 ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK; 970 ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE; 971 ctx->Light.ColorMaterialBitmask 972 = gl_material_bitmask( ctx, 973 GL_FRONT_AND_BACK, 974 GL_AMBIENT_AND_DIFFUSE, ~0, 0 ); 975 976 ctx->Light.ColorMaterialEnabled = GL_FALSE; 977 978 /* Lighting miscellaneous */ 979 ctx->ShineTabList = MALLOC_STRUCT( gl_shine_tab ); 980 make_empty_list( ctx->ShineTabList ); 981 for (i = 0 ; i < 10 ; i++) { 982 struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab ); 983 s->shininess = -1; 984 s->refcount = 0; 985 insert_at_tail( ctx->ShineTabList, s ); 986 } 987 for (i = 0 ; i < 4 ; i++) { 988 ctx->ShineTable[i] = ctx->ShineTabList->prev; 989 ctx->ShineTable[i]->refcount++; 990 } 991 992 993 /* Line group */ 994 ctx->Line.SmoothFlag = GL_FALSE; 995 ctx->Line.StippleFlag = GL_FALSE; 996 ctx->Line.Width = 1.0; 997 ctx->Line.StipplePattern = 0xffff; 998 ctx->Line.StippleFactor = 1; 999 1000 /* Display List group */ 1001 ctx->List.ListBase = 0; 1002 1003 /* Pixel group */ 1004 ctx->Pixel.RedBias = 0.0; 1005 ctx->Pixel.RedScale = 1.0; 1006 ctx->Pixel.GreenBias = 0.0; 1007 ctx->Pixel.GreenScale = 1.0; 1008 ctx->Pixel.BlueBias = 0.0; 1009 ctx->Pixel.BlueScale = 1.0; 1010 ctx->Pixel.AlphaBias = 0.0; 1011 ctx->Pixel.AlphaScale = 1.0; 1012 ctx->Pixel.ScaleOrBiasRGBA = GL_FALSE; 1013 ctx->Pixel.DepthBias = 0.0; 1014 ctx->Pixel.DepthScale = 1.0; 1015 ctx->Pixel.IndexOffset = 0; 1016 ctx->Pixel.IndexShift = 0; 1017 ctx->Pixel.ZoomX = 1.0; 1018 ctx->Pixel.ZoomY = 1.0; 1019 ctx->Pixel.MapColorFlag = GL_FALSE; 1020 ctx->Pixel.MapStencilFlag = GL_FALSE; 1021 ctx->Pixel.MapStoSsize = 1; 1022 ctx->Pixel.MapItoIsize = 1; 1023 ctx->Pixel.MapItoRsize = 1; 1024 ctx->Pixel.MapItoGsize = 1; 1025 ctx->Pixel.MapItoBsize = 1; 1026 ctx->Pixel.MapItoAsize = 1; 1027 ctx->Pixel.MapRtoRsize = 1; 1028 ctx->Pixel.MapGtoGsize = 1; 1029 ctx->Pixel.MapBtoBsize = 1; 1030 ctx->Pixel.MapAtoAsize = 1; 1031 ctx->Pixel.MapStoS[0] = 0; 1032 ctx->Pixel.MapItoI[0] = 0; 1033 ctx->Pixel.MapItoR[0] = 0.0; 1034 ctx->Pixel.MapItoG[0] = 0.0; 1035 ctx->Pixel.MapItoB[0] = 0.0; 1036 ctx->Pixel.MapItoA[0] = 0.0; 1037 ctx->Pixel.MapItoR8[0] = 0; 1038 ctx->Pixel.MapItoG8[0] = 0; 1039 ctx->Pixel.MapItoB8[0] = 0; 1040 ctx->Pixel.MapItoA8[0] = 0; 1041 ctx->Pixel.MapRtoR[0] = 0.0; 1042 ctx->Pixel.MapGtoG[0] = 0.0; 1043 ctx->Pixel.MapBtoB[0] = 0.0; 1044 ctx->Pixel.MapAtoA[0] = 0.0; 1045 1046 /* Point group */ 1047 ctx->Point.SmoothFlag = GL_FALSE; 1048 ctx->Point.Size = 1.0; 1049 ctx->Point.Params[0] = 1.0; 1050 ctx->Point.Params[1] = 0.0; 1051 ctx->Point.Params[2] = 0.0; 1052 ctx->Point.Attenuated = GL_FALSE; 1053 ctx->Point.MinSize = 0.0; 1054 ctx->Point.MaxSize = (GLfloat) MAX_POINT_SIZE; 1055 ctx->Point.Threshold = 1.0; 1056 1057 /* Polygon group */ 1058 ctx->Polygon.CullFlag = GL_FALSE; 1059 ctx->Polygon.CullFaceMode = GL_BACK; 1060 ctx->Polygon.FrontFace = GL_CCW; 1061 ctx->Polygon.FrontBit = 0; 1062 ctx->Polygon.FrontMode = GL_FILL; 1063 ctx->Polygon.BackMode = GL_FILL; 1064 ctx->Polygon.Unfilled = GL_FALSE; 1065 ctx->Polygon.SmoothFlag = GL_FALSE; 1066 ctx->Polygon.StippleFlag = GL_FALSE; 1067 ctx->Polygon.OffsetFactor = 0.0F; 1068 ctx->Polygon.OffsetUnits = 0.0F; 1069 ctx->Polygon.OffsetPoint = GL_FALSE; 1070 ctx->Polygon.OffsetLine = GL_FALSE; 1071 ctx->Polygon.OffsetFill = GL_FALSE; 1072 1073 /* Polygon Stipple group */ 1074 MEMSET( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) ); 1075 1076 /* Scissor group */ 1077 ctx->Scissor.Enabled = GL_FALSE; 1078 ctx->Scissor.X = 0; 1079 ctx->Scissor.Y = 0; 1080 ctx->Scissor.Width = 0; 1081 ctx->Scissor.Height = 0; 1082 1083 /* Stencil group */ 1084 ctx->Stencil.Enabled = GL_FALSE; 1085 ctx->Stencil.Function = GL_ALWAYS; 1086 ctx->Stencil.FailFunc = GL_KEEP; 1087 ctx->Stencil.ZPassFunc = GL_KEEP; 1088 ctx->Stencil.ZFailFunc = GL_KEEP; 1089 ctx->Stencil.Ref = 0; 1090 ctx->Stencil.ValueMask = STENCIL_MAX; 1091 ctx->Stencil.Clear = 0; 1092 ctx->Stencil.WriteMask = STENCIL_MAX; 1093 1094 /* Texture group */ 1095 ctx->Texture.CurrentUnit = 0; /* multitexture */ 1096 ctx->Texture.CurrentTransformUnit = 0; /* multitexture */ 1097 ctx->Texture.Enabled = 0; 1098 for (i=0; i<MAX_TEXTURE_UNITS; i++) 1099 init_texture_unit( ctx, i ); 1100 init_color_table(&ctx->Texture.Palette); 1101 1102 /* Transformation group */ 1103 ctx->Transform.MatrixMode = GL_MODELVIEW; 1104 ctx->Transform.Normalize = GL_FALSE; 1105 ctx->Transform.RescaleNormals = GL_FALSE; 1106 for (i=0;i<MAX_CLIP_PLANES;i++) { 1107 ctx->Transform.ClipEnabled[i] = GL_FALSE; 1108 ASSIGN_4V( ctx->Transform.EyeUserPlane[i], 0.0, 0.0, 0.0, 0.0 ); 1109 } 1110 ctx->Transform.AnyClip = GL_FALSE; 1111 1112 /* Viewport group */ 1113 ctx->Viewport.X = 0; 1114 ctx->Viewport.Y = 0; 1115 ctx->Viewport.Width = 0; 1116 ctx->Viewport.Height = 0; 1117 ctx->Viewport.Near = 0.0; 1118 ctx->Viewport.Far = 1.0; 1119 gl_matrix_ctr(&ctx->Viewport.WindowMap); 1120 1121#define Sz 10 1122#define Tz 14 1123 ctx->Viewport.WindowMap.m[Sz] = 0.5 * ctx->Visual->DepthMaxF; 1124 ctx->Viewport.WindowMap.m[Tz] = 0.5 * ctx->Visual->DepthMaxF; 1125#undef Sz 1126#undef Tz 1127 1128 ctx->Viewport.WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION; 1129 ctx->Viewport.WindowMap.type = MATRIX_3D_NO_ROT; 1130 1131 /* Vertex arrays */ 1132 ctx->Array.Vertex.Size = 4; 1133 ctx->Array.Vertex.Type = GL_FLOAT; 1134 ctx->Array.Vertex.Stride = 0; 1135 ctx->Array.Vertex.StrideB = 0; 1136 ctx->Array.Vertex.Ptr = NULL; 1137 ctx->Array.Vertex.Enabled = GL_FALSE; 1138 ctx->Array.Normal.Type = GL_FLOAT; 1139 ctx->Array.Normal.Stride = 0; 1140 ctx->Array.Normal.StrideB = 0; 1141 ctx->Array.Normal.Ptr = NULL; 1142 ctx->Array.Normal.Enabled = GL_FALSE; 1143 ctx->Array.Color.Size = 4; 1144 ctx->Array.Color.Type = GL_FLOAT; 1145 ctx->Array.Color.Stride = 0; 1146 ctx->Array.Color.StrideB = 0; 1147 ctx->Array.Color.Ptr = NULL; 1148 ctx->Array.Color.Enabled = GL_FALSE; 1149 ctx->Array.Index.Type = GL_FLOAT; 1150 ctx->Array.Index.Stride = 0; 1151 ctx->Array.Index.StrideB = 0; 1152 ctx->Array.Index.Ptr = NULL; 1153 ctx->Array.Index.Enabled = GL_FALSE; 1154 for (i = 0; i < MAX_TEXTURE_UNITS; i++) { 1155 ctx->Array.TexCoord[i].Size = 4; 1156 ctx->Array.TexCoord[i].Type = GL_FLOAT; 1157 ctx->Array.TexCoord[i].Stride = 0; 1158 ctx->Array.TexCoord[i].StrideB = 0; 1159 ctx->Array.TexCoord[i].Ptr = NULL; 1160 ctx->Array.TexCoord[i].Enabled = GL_FALSE; 1161 } 1162 ctx->Array.TexCoordInterleaveFactor = 1; 1163 ctx->Array.EdgeFlag.Stride = 0; 1164 ctx->Array.EdgeFlag.StrideB = 0; 1165 ctx->Array.EdgeFlag.Ptr = NULL; 1166 ctx->Array.EdgeFlag.Enabled = GL_FALSE; 1167 ctx->Array.ActiveTexture = 0; /* GL_ARB_multitexture */ 1168 1169 /* Pixel transfer */ 1170 ctx->Pack.Alignment = 4; 1171 ctx->Pack.RowLength = 0; 1172 ctx->Pack.ImageHeight = 0; 1173 ctx->Pack.SkipPixels = 0; 1174 ctx->Pack.SkipRows = 0; 1175 ctx->Pack.SkipImages = 0; 1176 ctx->Pack.SwapBytes = GL_FALSE; 1177 ctx->Pack.LsbFirst = GL_FALSE; 1178 ctx->Unpack.Alignment = 4; 1179 ctx->Unpack.RowLength = 0; 1180 ctx->Unpack.ImageHeight = 0; 1181 ctx->Unpack.SkipPixels = 0; 1182 ctx->Unpack.SkipRows = 0; 1183 ctx->Unpack.SkipImages = 0; 1184 ctx->Unpack.SwapBytes = GL_FALSE; 1185 ctx->Unpack.LsbFirst = GL_FALSE; 1186 1187 /* Feedback */ 1188 ctx->Feedback.Type = GL_2D; /* TODO: verify */ 1189 ctx->Feedback.Buffer = NULL; 1190 ctx->Feedback.BufferSize = 0; 1191 ctx->Feedback.Count = 0; 1192 1193 /* Selection/picking */ 1194 ctx->Select.Buffer = NULL; 1195 ctx->Select.BufferSize = 0; 1196 ctx->Select.BufferCount = 0; 1197 ctx->Select.Hits = 0; 1198 ctx->Select.NameStackDepth = 0; 1199 1200 /* Optimized Accum buffer */ 1201 ctx->IntegerAccumMode = GL_TRUE; 1202 ctx->IntegerAccumScaler = 0.0; 1203 1204 /* Renderer and client attribute stacks */ 1205 ctx->AttribStackDepth = 0; 1206 ctx->ClientAttribStackDepth = 0; 1207 1208 /* Miscellaneous */ 1209 ctx->NewState = NEW_ALL; 1210 ctx->RenderMode = GL_RENDER; 1211 ctx->StippleCounter = 0; 1212 ctx->NeedNormals = GL_FALSE; 1213 ctx->DoViewportMapping = GL_TRUE; 1214 1215 ctx->NeedEyeCoords = GL_FALSE; 1216 ctx->NeedEyeNormals = GL_FALSE; 1217 ctx->vb_proj_matrix = &ctx->ModelProjectMatrix; 1218 1219 /* Display list */ 1220 ctx->CallDepth = 0; 1221 ctx->ExecuteFlag = GL_TRUE; 1222 ctx->CompileFlag = GL_FALSE; 1223 ctx->CurrentListPtr = NULL; 1224 ctx->CurrentBlock = NULL; 1225 ctx->CurrentListNum = 0; 1226 ctx->CurrentPos = 0; 1227 1228 ctx->ErrorValue = (GLenum) GL_NO_ERROR; 1229 1230 ctx->CatchSignals = GL_TRUE; 1231 ctx->OcclusionResult = GL_FALSE; 1232 1233 /* For debug/development only */ 1234 ctx->NoRaster = getenv("MESA_NO_RASTER") ? GL_TRUE : GL_FALSE; 1235 ctx->FirstTimeCurrent = GL_TRUE; 1236 1237 /* Dither disable */ 1238 ctx->NoDither = getenv("MESA_NO_DITHER") ? GL_TRUE : GL_FALSE; 1239 if (ctx->NoDither) { 1240 if (getenv("MESA_DEBUG")) { 1241 fprintf(stderr, "MESA_NO_DITHER set - dithering disabled\n"); 1242 } 1243 ctx->Color.DitherFlag = GL_FALSE; 1244 } 1245} 1246 1247 1248 1249 1250/* 1251 * Allocate the proxy textures. If we run out of memory part way through 1252 * the allocations clean up and return GL_FALSE. 1253 * Return: GL_TRUE=success, GL_FALSE=failure 1254 */ 1255static GLboolean alloc_proxy_textures( GLcontext *ctx ) 1256{ 1257 GLboolean out_of_memory; 1258 GLint i; 1259 1260 ctx->Texture.Proxy1D = gl_alloc_texture_object(NULL, 0, 1); 1261 if (!ctx->Texture.Proxy1D) { 1262 return GL_FALSE; 1263 } 1264 1265 ctx->Texture.Proxy2D = gl_alloc_texture_object(NULL, 0, 2); 1266 if (!ctx->Texture.Proxy2D) { 1267 gl_free_texture_object(NULL, ctx->Texture.Proxy1D); 1268 return GL_FALSE; 1269 } 1270 1271 ctx->Texture.Proxy3D = gl_alloc_texture_object(NULL, 0, 3); 1272 if (!ctx->Texture.Proxy3D) { 1273 gl_free_texture_object(NULL, ctx->Texture.Proxy1D); 1274 gl_free_texture_object(NULL, ctx->Texture.Proxy2D); 1275 return GL_FALSE; 1276 } 1277 1278 out_of_memory = GL_FALSE; 1279 for (i=0;i<MAX_TEXTURE_LEVELS;i++) { 1280 ctx->Texture.Proxy1D->Image[i] = _mesa_alloc_texture_image(); 1281 ctx->Texture.Proxy2D->Image[i] = _mesa_alloc_texture_image(); 1282 ctx->Texture.Proxy3D->Image[i] = _mesa_alloc_texture_image(); 1283 if (!ctx->Texture.Proxy1D->Image[i] 1284 || !ctx->Texture.Proxy2D->Image[i] 1285 || !ctx->Texture.Proxy3D->Image[i]) { 1286 out_of_memory = GL_TRUE; 1287 } 1288 } 1289 if (out_of_memory) { 1290 for (i=0;i<MAX_TEXTURE_LEVELS;i++) { 1291 if (ctx->Texture.Proxy1D->Image[i]) { 1292 _mesa_free_texture_image(ctx->Texture.Proxy1D->Image[i]); 1293 } 1294 if (ctx->Texture.Proxy2D->Image[i]) { 1295 _mesa_free_texture_image(ctx->Texture.Proxy2D->Image[i]); 1296 } 1297 if (ctx->Texture.Proxy3D->Image[i]) { 1298 _mesa_free_texture_image(ctx->Texture.Proxy3D->Image[i]); 1299 } 1300 } 1301 gl_free_texture_object(NULL, ctx->Texture.Proxy1D); 1302 gl_free_texture_object(NULL, ctx->Texture.Proxy2D); 1303 gl_free_texture_object(NULL, ctx->Texture.Proxy3D); 1304 return GL_FALSE; 1305 } 1306 else { 1307 return GL_TRUE; 1308 } 1309} 1310 1311 1312 1313/* 1314 * Initialize a GLcontext struct. 1315 */ 1316GLboolean gl_initialize_context_data( GLcontext *ctx, 1317 GLvisual *visual, 1318 GLcontext *share_list, 1319 void *driver_ctx, 1320 GLboolean direct ) 1321{ 1322 (void) direct; /* not used */ 1323 1324 /* misc one-time initializations */ 1325 one_time_init(); 1326 1327 ctx->DriverCtx = driver_ctx; 1328 ctx->Visual = visual; 1329 ctx->DrawBuffer = NULL; 1330 ctx->ReadBuffer = NULL; 1331 1332 ctx->VB = gl_vb_create_for_immediate( ctx ); 1333 if (!ctx->VB) { 1334 FREE( ctx ); 1335 return GL_FALSE; 1336 } 1337 ctx->input = ctx->VB->IM; 1338 1339 ctx->PB = gl_alloc_pb(); 1340 if (!ctx->PB) { 1341 FREE( ctx->VB ); 1342 FREE( ctx ); 1343 return GL_FALSE; 1344 } 1345 1346 if (share_list) { 1347 /* share the group of display lists of another context */ 1348 ctx->Shared = share_list->Shared; 1349 } 1350 else { 1351 /* allocate new group of display lists */ 1352 ctx->Shared = alloc_shared_state(); 1353 if (!ctx->Shared) { 1354 FREE(ctx->VB); 1355 FREE(ctx->PB); 1356 FREE(ctx); 1357 return GL_FALSE; 1358 } 1359 } 1360 _glthread_LOCK_MUTEX(ctx->Shared->Mutex); 1361 ctx->Shared->RefCount++; 1362 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); 1363 1364 init_attrib_groups( ctx ); 1365 1366 gl_reset_vb( ctx->VB ); 1367 gl_reset_input( ctx ); 1368 1369 if (visual->DBflag) { 1370 ctx->Color.DrawBuffer = GL_BACK; 1371 ctx->Color.DriverDrawBuffer = GL_BACK_LEFT; 1372 ctx->Color.DrawDestMask = BACK_LEFT_BIT; 1373 ctx->Pixel.ReadBuffer = GL_BACK; 1374 ctx->Pixel.DriverReadBuffer = GL_BACK_LEFT; 1375 } 1376 else { 1377 ctx->Color.DrawBuffer = GL_FRONT; 1378 ctx->Color.DriverDrawBuffer = GL_FRONT_LEFT; 1379 ctx->Color.DrawDestMask = FRONT_LEFT_BIT; 1380 ctx->Pixel.ReadBuffer = GL_FRONT; 1381 ctx->Pixel.DriverReadBuffer = GL_FRONT_LEFT; 1382 } 1383 1384#ifdef PROFILE 1385 init_timings( ctx ); 1386#endif 1387 1388 if (!alloc_proxy_textures(ctx)) { 1389 free_shared_state(ctx, ctx->Shared); 1390 FREE(ctx->VB); 1391 FREE(ctx->PB); 1392 FREE(ctx); 1393 return GL_FALSE; 1394 } 1395 1396 /* setup API dispatch tables */ 1397 ctx->Exec = (struct _glapi_table *) CALLOC(_glapi_get_dispatch_table_size() * sizeof(void *)); 1398 ctx->Save = (struct _glapi_table *) CALLOC(_glapi_get_dispatch_table_size() * sizeof(void *)); 1399 if (!ctx->Exec || !ctx->Save) { 1400 free_shared_state(ctx, ctx->Shared); 1401 FREE(ctx->VB); 1402 FREE(ctx->PB); 1403 if (ctx->Exec) 1404 FREE(ctx->Exec); 1405 FREE(ctx); 1406 } 1407 _mesa_init_exec_table( ctx->Exec ); 1408 _mesa_init_dlist_table( ctx->Save ); 1409 ctx->CurrentDispatch = ctx->Exec; 1410 1411 return GL_TRUE; 1412} 1413 1414 1415 1416/* 1417 * Allocate and initialize a GLcontext structure. 1418 * Input: visual - a GLvisual pointer 1419 * sharelist - another context to share display lists with or NULL 1420 * driver_ctx - pointer to device driver's context state struct 1421 * Return: pointer to a new gl_context struct or NULL if error. 1422 */ 1423GLcontext *gl_create_context( GLvisual *visual, 1424 GLcontext *share_list, 1425 void *driver_ctx, 1426 GLboolean direct ) 1427{ 1428 GLcontext *ctx = (GLcontext *) CALLOC( sizeof(GLcontext) ); 1429 if (!ctx) { 1430 return NULL; 1431 } 1432 1433 if (gl_initialize_context_data(ctx, visual, share_list, 1434 driver_ctx, direct)) { 1435 return ctx; 1436 } 1437 else { 1438 FREE(ctx); 1439 return NULL; 1440 } 1441} 1442 1443 1444 1445/* 1446 * Free the data associated with the given context. 1447 * But don't free() the GLcontext struct itself! 1448 */ 1449void gl_free_context_data( GLcontext *ctx ) 1450{ 1451 struct gl_shine_tab *s, *tmps; 1452 GLuint i, j; 1453 1454 /* if we're destroying the current context, unbind it first */ 1455 if (ctx == gl_get_current_context()) { 1456 gl_make_current(NULL, NULL); 1457 } 1458 1459#ifdef PROFILE 1460 if (getenv("MESA_PROFILE")) { 1461 print_timings( ctx ); 1462 } 1463#endif 1464 1465 gl_matrix_dtr( &ctx->ModelView ); 1466 for (i = 0; i < MAX_MODELVIEW_STACK_DEPTH - 1; i++) { 1467 gl_matrix_dtr( &ctx->ModelViewStack[i] ); 1468 } 1469 gl_matrix_dtr( &ctx->ProjectionMatrix ); 1470 for (i = 0; i < MAX_PROJECTION_STACK_DEPTH - 1; i++) { 1471 gl_matrix_dtr( &ctx->ProjectionStack[i] ); 1472 } 1473 for (i = 0; i < MAX_TEXTURE_UNITS; i++) { 1474 gl_matrix_dtr( &ctx->TextureMatrix[i] ); 1475 for (j = 0; j < MAX_TEXTURE_STACK_DEPTH - 1; j++) { 1476 gl_matrix_dtr( &ctx->TextureStack[i][j] ); 1477 } 1478 } 1479 1480 FREE( ctx->PB ); 1481 1482 if(ctx->input != ctx->VB->IM) 1483 gl_immediate_free( ctx->input ); 1484 1485 gl_vb_free( ctx->VB ); 1486 1487 _glthread_LOCK_MUTEX(ctx->Shared->Mutex); 1488 ctx->Shared->RefCount--; 1489 assert(ctx->Shared->RefCount >= 0); 1490 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); 1491 if (ctx->Shared->RefCount == 0) { 1492 /* free shared state */ 1493 free_shared_state( ctx, ctx->Shared ); 1494 } 1495 1496 foreach_s( s, tmps, ctx->ShineTabList ) { 1497 FREE( s ); 1498 } 1499 FREE( ctx->ShineTabList ); 1500 1501 /* Free proxy texture objects */ 1502 gl_free_texture_object( NULL, ctx->Texture.Proxy1D ); 1503 gl_free_texture_object( NULL, ctx->Texture.Proxy2D ); 1504 gl_free_texture_object( NULL, ctx->Texture.Proxy3D ); 1505 1506 /* Free evaluator data */ 1507 if (ctx->EvalMap.Map1Vertex3.Points) 1508 FREE( ctx->EvalMap.Map1Vertex3.Points ); 1509 if (ctx->EvalMap.Map1Vertex4.Points) 1510 FREE( ctx->EvalMap.Map1Vertex4.Points ); 1511 if (ctx->EvalMap.Map1Index.Points) 1512 FREE( ctx->EvalMap.Map1Index.Points ); 1513 if (ctx->EvalMap.Map1Color4.Points) 1514 FREE( ctx->EvalMap.Map1Color4.Points ); 1515 if (ctx->EvalMap.Map1Normal.Points) 1516 FREE( ctx->EvalMap.Map1Normal.Points ); 1517 if (ctx->EvalMap.Map1Texture1.Points) 1518 FREE( ctx->EvalMap.Map1Texture1.Points ); 1519 if (ctx->EvalMap.Map1Texture2.Points) 1520 FREE( ctx->EvalMap.Map1Texture2.Points ); 1521 if (ctx->EvalMap.Map1Texture3.Points) 1522 FREE( ctx->EvalMap.Map1Texture3.Points ); 1523 if (ctx->EvalMap.Map1Texture4.Points) 1524 FREE( ctx->EvalMap.Map1Texture4.Points ); 1525 1526 if (ctx->EvalMap.Map2Vertex3.Points) 1527 FREE( ctx->EvalMap.Map2Vertex3.Points ); 1528 if (ctx->EvalMap.Map2Vertex4.Points) 1529 FREE( ctx->EvalMap.Map2Vertex4.Points ); 1530 if (ctx->EvalMap.Map2Index.Points) 1531 FREE( ctx->EvalMap.Map2Index.Points ); 1532 if (ctx->EvalMap.Map2Color4.Points) 1533 FREE( ctx->EvalMap.Map2Color4.Points ); 1534 if (ctx->EvalMap.Map2Normal.Points) 1535 FREE( ctx->EvalMap.Map2Normal.Points ); 1536 if (ctx->EvalMap.Map2Texture1.Points) 1537 FREE( ctx->EvalMap.Map2Texture1.Points ); 1538 if (ctx->EvalMap.Map2Texture2.Points) 1539 FREE( ctx->EvalMap.Map2Texture2.Points ); 1540 if (ctx->EvalMap.Map2Texture3.Points) 1541 FREE( ctx->EvalMap.Map2Texture3.Points ); 1542 if (ctx->EvalMap.Map2Texture4.Points) 1543 FREE( ctx->EvalMap.Map2Texture4.Points ); 1544 1545 /* Free cache of immediate buffers. */ 1546 while (ctx->nr_im_queued-- > 0) { 1547 struct immediate * next = ctx->freed_im_queue->next; 1548 FREE( ctx->freed_im_queue ); 1549 ctx->freed_im_queue = next; 1550 } 1551 gl_extensions_dtr(ctx); 1552 1553 FREE(ctx->Exec); 1554 FREE(ctx->Save); 1555} 1556 1557 1558 1559/* 1560 * Destroy a GLcontext structure. 1561 */ 1562void gl_destroy_context( GLcontext *ctx ) 1563{ 1564 if (ctx) { 1565 gl_free_context_data(ctx); 1566 FREE( (void *) ctx ); 1567 } 1568} 1569 1570 1571 1572/* 1573 * Called by the driver after both the context and driver are fully 1574 * initialized. Currently just reads the config file. 1575 */ 1576void gl_context_initialize( GLcontext *ctx ) 1577{ 1578 gl_read_config_file( ctx ); 1579} 1580 1581 1582 1583/* 1584 * Copy attribute groups from one context to another. 1585 * Input: src - source context 1586 * dst - destination context 1587 * mask - bitwise OR of GL_*_BIT flags 1588 */ 1589void gl_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask ) 1590{ 1591 if (mask & GL_ACCUM_BUFFER_BIT) { 1592 MEMCPY( &dst->Accum, &src->Accum, sizeof(struct gl_accum_attrib) ); 1593 } 1594 if (mask & GL_COLOR_BUFFER_BIT) { 1595 MEMCPY( &dst->Color, &src->Color, sizeof(struct gl_colorbuffer_attrib) ); 1596 } 1597 if (mask & GL_CURRENT_BIT) { 1598 MEMCPY( &dst->Current, &src->Current, sizeof(struct gl_current_attrib) ); 1599 } 1600 if (mask & GL_DEPTH_BUFFER_BIT) { 1601 MEMCPY( &dst->Depth, &src->Depth, sizeof(struct gl_depthbuffer_attrib) ); 1602 } 1603 if (mask & GL_ENABLE_BIT) { 1604 /* no op */ 1605 } 1606 if (mask & GL_EVAL_BIT) { 1607 MEMCPY( &dst->Eval, &src->Eval, sizeof(struct gl_eval_attrib) ); 1608 } 1609 if (mask & GL_FOG_BIT) { 1610 MEMCPY( &dst->Fog, &src->Fog, sizeof(struct gl_fog_attrib) ); 1611 } 1612 if (mask & GL_HINT_BIT) { 1613 MEMCPY( &dst->Hint, &src->Hint, sizeof(struct gl_hint_attrib) ); 1614 } 1615 if (mask & GL_LIGHTING_BIT) { 1616 MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light_attrib) ); 1617 /* gl_reinit_light_attrib( &dst->Light ); */ 1618 } 1619 if (mask & GL_LINE_BIT) { 1620 MEMCPY( &dst->Line, &src->Line, sizeof(struct gl_line_attrib) ); 1621 } 1622 if (mask & GL_LIST_BIT) { 1623 MEMCPY( &dst->List, &src->List, sizeof(struct gl_list_attrib) ); 1624 } 1625 if (mask & GL_PIXEL_MODE_BIT) { 1626 MEMCPY( &dst->Pixel, &src->Pixel, sizeof(struct gl_pixel_attrib) ); 1627 } 1628 if (mask & GL_POINT_BIT) { 1629 MEMCPY( &dst->Point, &src->Point, sizeof(struct gl_point_attrib) ); 1630 } 1631 if (mask & GL_POLYGON_BIT) { 1632 MEMCPY( &dst->Polygon, &src->Polygon, sizeof(struct gl_polygon_attrib) ); 1633 } 1634 if (mask & GL_POLYGON_STIPPLE_BIT) { 1635 /* Use loop instead of MEMCPY due to problem with Portland Group's 1636 * C compiler. Reported by John Stone. 1637 */ 1638 int i; 1639 for (i=0;i<32;i++) { 1640 dst->PolygonStipple[i] = src->PolygonStipple[i]; 1641 } 1642 } 1643 if (mask & GL_SCISSOR_BIT) { 1644 MEMCPY( &dst->Scissor, &src->Scissor, sizeof(struct gl_scissor_attrib) ); 1645 } 1646 if (mask & GL_STENCIL_BUFFER_BIT) { 1647 MEMCPY( &dst->Stencil, &src->Stencil, sizeof(struct gl_stencil_attrib) ); 1648 } 1649 if (mask & GL_TEXTURE_BIT) { 1650 MEMCPY( &dst->Texture, &src->Texture, sizeof(struct gl_texture_attrib) ); 1651 } 1652 if (mask & GL_TRANSFORM_BIT) { 1653 MEMCPY( &dst->Transform, &src->Transform, sizeof(struct gl_transform_attrib) ); 1654 } 1655 if (mask & GL_VIEWPORT_BIT) { 1656 MEMCPY( &dst->Viewport, &src->Viewport, sizeof(struct gl_viewport_attrib) ); 1657 } 1658} 1659 1660 1661/* 1662 * Set the current context, binding the given frame buffer to the context. 1663 */ 1664void gl_make_current( GLcontext *newCtx, GLframebuffer *buffer ) 1665{ 1666 gl_make_current2( newCtx, buffer, buffer ); 1667} 1668 1669 1670/* 1671 * Bind the given context to the given draw-buffer and read-buffer 1672 * and make it the current context for this thread. 1673 */ 1674void gl_make_current2( GLcontext *newCtx, GLframebuffer *drawBuffer, 1675 GLframebuffer *readBuffer ) 1676{ 1677#if 0 1678 GLcontext *oldCtx = gl_get_context(); 1679 1680 /* Flush the old context 1681 */ 1682 if (oldCtx) { 1683 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(oldCtx, "gl_make_current"); 1684 1685 /* unbind frame buffers from context */ 1686 if (oldCtx->DrawBuffer) { 1687 oldCtx->DrawBuffer = NULL; 1688 } 1689 if (oldCtx->ReadBuffer) { 1690 oldCtx->ReadBuffer = NULL; 1691 } 1692 } 1693#endif 1694 1695 /* We call this function periodically (just here for now) in 1696 * order to detect when multithreading has begun. 1697 */ 1698 _glapi_check_multithread(); 1699 1700 _glapi_set_context((void *) newCtx); 1701 ASSERT(gl_get_current_context() == newCtx); 1702 if (newCtx) { 1703 SET_IMMEDIATE(newCtx, newCtx->input); 1704 _glapi_set_dispatch(newCtx->CurrentDispatch); 1705 } 1706 else { 1707 _glapi_set_dispatch(NULL); /* none current */ 1708 } 1709 1710 if (MESA_VERBOSE) fprintf(stderr, "gl_make_current()\n"); 1711 1712 if (newCtx && drawBuffer && readBuffer) { 1713 /* TODO: check if newCtx and buffer's visual match??? */ 1714 newCtx->DrawBuffer = drawBuffer; 1715 newCtx->ReadBuffer = readBuffer; 1716 newCtx->NewState = NEW_ALL; /* just to be safe */ 1717 gl_update_state( newCtx ); 1718 } 1719 1720 /* We can use this to help debug user's problems. Tell the to set 1721 * the MESA_INFO env variable before running their app. Then the 1722 * first time each context is made current we'll print some useful 1723 * information. 1724 */ 1725 if (newCtx && newCtx->FirstTimeCurrent) { 1726 if (getenv("MESA_INFO")) { 1727 fprintf(stderr, "Mesa GL_VERSION = %s\n", (char *) _mesa_GetString(GL_VERSION)); 1728 fprintf(stderr, "Mesa GL_RENDERER = %s\n", (char *) _mesa_GetString(GL_RENDERER)); 1729 fprintf(stderr, "Mesa GL_VENDOR = %s\n", (char *) _mesa_GetString(GL_VENDOR)); 1730 fprintf(stderr, "Mesa GL_EXTENSIONS = %s\n", (char *) _mesa_GetString(GL_EXTENSIONS)); 1731#if defined(THREADS) 1732 fprintf(stderr, "Mesa thread-safe: YES\n"); 1733#else 1734 fprintf(stderr, "Mesa thread-safe: NO\n"); 1735#endif 1736#if defined(USE_X86_ASM) 1737 fprintf(stderr, "Mesa x86-optimized: YES\n"); 1738#else 1739 fprintf(stderr, "Mesa x86-optimized: NO\n"); 1740#endif 1741 } 1742 newCtx->FirstTimeCurrent = GL_FALSE; 1743 } 1744} 1745 1746 1747 1748/* 1749 * Return current context handle for the calling thread. 1750 * This isn't the fastest way to get the current context. 1751 * If you need speed, see the GET_CURRENT_CONTEXT() macro in context.h 1752 */ 1753GLcontext *gl_get_current_context( void ) 1754{ 1755 return (GLcontext *) _glapi_get_context(); 1756} 1757 1758 1759 1760/* 1761 * This should be called by device drivers just before they do a 1762 * swapbuffers. Any pending rendering commands will be executed. 1763 */ 1764void 1765_mesa_swapbuffers(GLcontext *ctx) 1766{ 1767 FLUSH_VB( ctx, "swap buffers" ); 1768} 1769 1770 1771 1772/* 1773 * Return pointer to this context's current API dispatch table. 1774 * It'll either be the immediate-mode execute dispatcher or the 1775 * display list compile dispatcher. 1776 */ 1777struct _glapi_table * 1778_mesa_get_dispatch(GLcontext *ctx) 1779{ 1780 return ctx->CurrentDispatch; 1781} 1782 1783 1784 1785/**********************************************************************/ 1786/***** Miscellaneous functions *****/ 1787/**********************************************************************/ 1788 1789 1790/* 1791 * This function is called when the Mesa user has stumbled into a code 1792 * path which may not be implemented fully or correctly. 1793 */ 1794void gl_problem( const GLcontext *ctx, const char *s ) 1795{ 1796 fprintf( stderr, "Mesa implementation error: %s\n", s ); 1797 fprintf( stderr, "Report to mesa-bugs@mesa3d.org\n" ); 1798 (void) ctx; 1799} 1800 1801 1802 1803/* 1804 * This is called to inform the user that he or she has tried to do 1805 * something illogical or if there's likely a bug in their program 1806 * (like enabled depth testing without a depth buffer). 1807 */ 1808void gl_warning( const GLcontext *ctx, const char *s ) 1809{ 1810 GLboolean debug; 1811#ifdef DEBUG 1812 debug = GL_TRUE; 1813#else 1814 if (getenv("MESA_DEBUG")) { 1815 debug = GL_TRUE; 1816 } 1817 else { 1818 debug = GL_FALSE; 1819 } 1820#endif 1821 if (debug) { 1822 fprintf( stderr, "Mesa warning: %s\n", s ); 1823 } 1824 (void) ctx; 1825} 1826 1827 1828 1829/* 1830 * Compile an error into current display list. 1831 */ 1832void gl_compile_error( GLcontext *ctx, GLenum error, const char *s ) 1833{ 1834 if (ctx->CompileFlag) 1835 gl_save_error( ctx, error, s ); 1836 1837 if (ctx->ExecuteFlag) 1838 gl_error( ctx, error, s ); 1839} 1840 1841 1842 1843/* 1844 * This is Mesa's error handler. Normally, all that's done is the updating 1845 * of the current error value. If Mesa is compiled with -DDEBUG or if the 1846 * environment variable "MESA_DEBUG" is defined then a real error message 1847 * is printed to stderr. 1848 * Input: error - the error value 1849 * s - a diagnostic string 1850 */ 1851void gl_error( GLcontext *ctx, GLenum error, const char *s ) 1852{ 1853 GLboolean debug; 1854 1855#ifdef DEBUG 1856 debug = GL_TRUE; 1857#else 1858 if (getenv("MESA_DEBUG")) { 1859 debug = GL_TRUE; 1860 } 1861 else { 1862 debug = GL_FALSE; 1863 } 1864#endif 1865 1866 if (debug) { 1867 char errstr[1000]; 1868 1869 switch (error) { 1870 case GL_NO_ERROR: 1871 strcpy( errstr, "GL_NO_ERROR" ); 1872 break; 1873 case GL_INVALID_VALUE: 1874 strcpy( errstr, "GL_INVALID_VALUE" ); 1875 break; 1876 case GL_INVALID_ENUM: 1877 strcpy( errstr, "GL_INVALID_ENUM" ); 1878 break; 1879 case GL_INVALID_OPERATION: 1880 strcpy( errstr, "GL_INVALID_OPERATION" ); 1881 break; 1882 case GL_STACK_OVERFLOW: 1883 strcpy( errstr, "GL_STACK_OVERFLOW" ); 1884 break; 1885 case GL_STACK_UNDERFLOW: 1886 strcpy( errstr, "GL_STACK_UNDERFLOW" ); 1887 break; 1888 case GL_OUT_OF_MEMORY: 1889 strcpy( errstr, "GL_OUT_OF_MEMORY" ); 1890 break; 1891 default: 1892 strcpy( errstr, "unknown" ); 1893 break; 1894 } 1895 fprintf( stderr, "Mesa user error: %s in %s\n", errstr, s ); 1896 } 1897 1898 if (ctx->ErrorValue==GL_NO_ERROR) { 1899 ctx->ErrorValue = error; 1900 } 1901 1902 /* Call device driver's error handler, if any. This is used on the Mac. */ 1903 if (ctx->Driver.Error) { 1904 (*ctx->Driver.Error)( ctx ); 1905 } 1906} 1907 1908 1909 1910void 1911_mesa_Finish( void ) 1912{ 1913 GET_CURRENT_CONTEXT(ctx); 1914 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glFinish"); 1915 if (ctx->Driver.Finish) { 1916 (*ctx->Driver.Finish)( ctx ); 1917 } 1918} 1919 1920 1921 1922void 1923_mesa_Flush( void ) 1924{ 1925 GET_CURRENT_CONTEXT(ctx); 1926 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glFlush"); 1927 if (ctx->Driver.Flush) { 1928 (*ctx->Driver.Flush)( ctx ); 1929 } 1930} 1931