state.c revision 098f9c5325de16bfb5bf8b0e93e0ec1871db4a76
1/* 2 * Mesa 3-D graphics library 3 * Version: 7.3 4 * 5 * Copyright (C) 1999-2008 Brian Paul 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 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25 26/** 27 * \file state.c 28 * State management. 29 * 30 * This file manages recalculation of derived values in struct gl_context. 31 */ 32 33 34#include "glheader.h" 35#include "mtypes.h" 36#include "context.h" 37#include "debug.h" 38#include "macros.h" 39#include "ffvertex_prog.h" 40#include "framebuffer.h" 41#include "light.h" 42#include "matrix.h" 43#include "pixel.h" 44#include "program/program.h" 45#include "program/prog_parameter.h" 46#include "state.h" 47#include "stencil.h" 48#include "texenvprogram.h" 49#include "texobj.h" 50#include "texstate.h" 51 52 53static void 54update_separate_specular(struct gl_context *ctx) 55{ 56 if (_mesa_need_secondary_color(ctx)) 57 ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR; 58 else 59 ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR; 60} 61 62 63/** 64 * Compute the index of the last array element that can be safely accessed 65 * in a vertex array. We can really only do this when the array lives in 66 * a VBO. 67 * The array->_MaxElement field will be updated. 68 * Later in glDrawArrays/Elements/etc we can do some bounds checking. 69 */ 70static void 71compute_max_element(struct gl_client_array *array) 72{ 73 assert(array->Enabled); 74 if (array->BufferObj->Name) { 75 GLsizeiptrARB offset = (GLsizeiptrARB) array->Ptr; 76 GLsizeiptrARB obj_size = (GLsizeiptrARB) array->BufferObj->Size; 77 78 if (offset < obj_size) { 79 array->_MaxElement = (obj_size - offset + 80 array->StrideB - 81 array->_ElementSize) / array->StrideB; 82 } else { 83 array->_MaxElement = 0; 84 } 85 } 86 else { 87 /* user-space array, no idea how big it is */ 88 array->_MaxElement = 2 * 1000 * 1000 * 1000; /* just a big number */ 89 } 90} 91 92 93/** 94 * Helper for update_arrays(). 95 * \return min(current min, array->_MaxElement). 96 */ 97static GLuint 98update_min(GLuint min, struct gl_client_array *array) 99{ 100 compute_max_element(array); 101 return MIN2(min, array->_MaxElement); 102} 103 104 105/** 106 * Update ctx->Array._MaxElement (the max legal index into all enabled arrays). 107 * Need to do this upon new array state or new buffer object state. 108 */ 109static void 110update_arrays( struct gl_context *ctx ) 111{ 112 struct gl_array_object *arrayObj = ctx->Array.ArrayObj; 113 GLuint i, min = ~0; 114 115 /* find min of _MaxElement values for all enabled arrays */ 116 117 /* 0 */ 118 if (ctx->VertexProgram._Current 119 && arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) { 120 min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_POS]); 121 } 122 else if (arrayObj->Vertex.Enabled) { 123 min = update_min(min, &arrayObj->Vertex); 124 } 125 126 /* 1 */ 127 if (ctx->VertexProgram._Enabled 128 && arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT].Enabled) { 129 min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT]); 130 } 131 /* no conventional vertex weight array */ 132 133 /* 2 */ 134 if (ctx->VertexProgram._Enabled 135 && arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) { 136 min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]); 137 } 138 else if (arrayObj->Normal.Enabled) { 139 min = update_min(min, &arrayObj->Normal); 140 } 141 142 /* 3 */ 143 if (ctx->VertexProgram._Enabled 144 && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) { 145 min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]); 146 } 147 else if (arrayObj->Color.Enabled) { 148 min = update_min(min, &arrayObj->Color); 149 } 150 151 /* 4 */ 152 if (ctx->VertexProgram._Enabled 153 && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) { 154 min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1]); 155 } 156 else if (arrayObj->SecondaryColor.Enabled) { 157 min = update_min(min, &arrayObj->SecondaryColor); 158 } 159 160 /* 5 */ 161 if (ctx->VertexProgram._Enabled 162 && arrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) { 163 min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_FOG]); 164 } 165 else if (arrayObj->FogCoord.Enabled) { 166 min = update_min(min, &arrayObj->FogCoord); 167 } 168 169 /* 6 */ 170 if (ctx->VertexProgram._Enabled 171 && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) { 172 min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]); 173 } 174 else if (arrayObj->Index.Enabled) { 175 min = update_min(min, &arrayObj->Index); 176 } 177 178 /* 7 */ 179 if (ctx->VertexProgram._Enabled 180 && arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) { 181 min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG]); 182 } 183 184 /* 8..15 */ 185 for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX7; i++) { 186 if (ctx->VertexProgram._Enabled 187 && arrayObj->VertexAttrib[i].Enabled) { 188 min = update_min(min, &arrayObj->VertexAttrib[i]); 189 } 190 else if (i - VERT_ATTRIB_TEX0 < ctx->Const.MaxTextureCoordUnits 191 && arrayObj->TexCoord[i - VERT_ATTRIB_TEX0].Enabled) { 192 min = update_min(min, &arrayObj->TexCoord[i - VERT_ATTRIB_TEX0]); 193 } 194 } 195 196 /* 16..31 */ 197 if (ctx->VertexProgram._Current) { 198 for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) { 199 if (arrayObj->VertexAttrib[i].Enabled) { 200 min = update_min(min, &arrayObj->VertexAttrib[i]); 201 } 202 } 203 } 204 205 if (arrayObj->EdgeFlag.Enabled) { 206 min = update_min(min, &arrayObj->EdgeFlag); 207 } 208 209 /* _MaxElement is one past the last legal array element */ 210 arrayObj->_MaxElement = min; 211} 212 213 214/** 215 * Update the following fields: 216 * ctx->VertexProgram._Enabled 217 * ctx->FragmentProgram._Enabled 218 * ctx->ATIFragmentShader._Enabled 219 * This needs to be done before texture state validation. 220 */ 221static void 222update_program_enables(struct gl_context *ctx) 223{ 224 /* These _Enabled flags indicate if the program is enabled AND valid. */ 225 ctx->VertexProgram._Enabled = ctx->VertexProgram.Enabled 226 && ctx->VertexProgram.Current->Base.Instructions; 227 ctx->FragmentProgram._Enabled = ctx->FragmentProgram.Enabled 228 && ctx->FragmentProgram.Current->Base.Instructions; 229 ctx->ATIFragmentShader._Enabled = ctx->ATIFragmentShader.Enabled 230 && ctx->ATIFragmentShader.Current->Instructions[0]; 231} 232 233 234/** 235 * Update vertex/fragment program state. In particular, update these fields: 236 * ctx->VertexProgram._Current 237 * ctx->VertexProgram._TnlProgram, 238 * These point to the highest priority enabled vertex/fragment program or are 239 * NULL if fixed-function processing is to be done. 240 * 241 * This function needs to be called after texture state validation in case 242 * we're generating a fragment program from fixed-function texture state. 243 * 244 * \return bitfield which will indicate _NEW_PROGRAM state if a new vertex 245 * or fragment program is being used. 246 */ 247static GLbitfield 248update_program(struct gl_context *ctx) 249{ 250 const struct gl_shader_program *vsProg = ctx->Shader.CurrentVertexProgram; 251 const struct gl_shader_program *gsProg = ctx->Shader.CurrentGeometryProgram; 252 const struct gl_shader_program *fsProg = ctx->Shader.CurrentFragmentProgram; 253 const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current; 254 const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current; 255 const struct gl_geometry_program *prevGP = ctx->GeometryProgram._Current; 256 GLbitfield new_state = 0x0; 257 258 /* 259 * Set the ctx->VertexProgram._Current and ctx->FragmentProgram._Current 260 * pointers to the programs that should be used for rendering. If either 261 * is NULL, use fixed-function code paths. 262 * 263 * These programs may come from several sources. The priority is as 264 * follows: 265 * 1. OpenGL 2.0/ARB vertex/fragment shaders 266 * 2. ARB/NV vertex/fragment programs 267 * 3. Programs derived from fixed-function state. 268 * 269 * Note: it's possible for a vertex shader to get used with a fragment 270 * program (and vice versa) here, but in practice that shouldn't ever 271 * come up, or matter. 272 */ 273 274 if (fsProg && fsProg->LinkStatus && fsProg->FragmentProgram) { 275 /* Use shader programs */ 276 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, 277 fsProg->FragmentProgram); 278 } 279 else if (ctx->FragmentProgram._Enabled) { 280 /* use user-defined vertex program */ 281 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, 282 ctx->FragmentProgram.Current); 283 } 284 else if (ctx->FragmentProgram._MaintainTexEnvProgram) { 285 /* Use fragment program generated from fixed-function state. 286 */ 287 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, 288 _mesa_get_fixed_func_fragment_program(ctx)); 289 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, 290 ctx->FragmentProgram._Current); 291 } 292 else { 293 /* no fragment program */ 294 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL); 295 } 296 297 if (gsProg && gsProg->LinkStatus && gsProg->GeometryProgram) { 298 /* Use shader programs */ 299 _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current, 300 gsProg->GeometryProgram); 301 } else { 302 /* no fragment program */ 303 _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current, NULL); 304 } 305 306 /* Examine vertex program after fragment program as 307 * _mesa_get_fixed_func_vertex_program() needs to know active 308 * fragprog inputs. 309 */ 310 if (vsProg && vsProg->LinkStatus && vsProg->VertexProgram) { 311 /* Use shader programs */ 312 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, 313 vsProg->VertexProgram); 314 } 315 else if (ctx->VertexProgram._Enabled) { 316 /* use user-defined vertex program */ 317 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, 318 ctx->VertexProgram.Current); 319 } 320 else if (ctx->VertexProgram._MaintainTnlProgram) { 321 /* Use vertex program generated from fixed-function state. 322 */ 323 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, 324 _mesa_get_fixed_func_vertex_program(ctx)); 325 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, 326 ctx->VertexProgram._Current); 327 } 328 else { 329 /* no vertex program */ 330 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL); 331 } 332 333 /* Let the driver know what's happening: 334 */ 335 if (ctx->FragmentProgram._Current != prevFP) { 336 new_state |= _NEW_PROGRAM; 337 if (ctx->Driver.BindProgram) { 338 ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 339 (struct gl_program *) ctx->FragmentProgram._Current); 340 } 341 } 342 343 if (ctx->GeometryProgram._Current != prevGP) { 344 new_state |= _NEW_PROGRAM; 345 if (ctx->Driver.BindProgram) { 346 ctx->Driver.BindProgram(ctx, MESA_GEOMETRY_PROGRAM, 347 (struct gl_program *) ctx->GeometryProgram._Current); 348 } 349 } 350 351 if (ctx->VertexProgram._Current != prevVP) { 352 new_state |= _NEW_PROGRAM; 353 if (ctx->Driver.BindProgram) { 354 ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB, 355 (struct gl_program *) ctx->VertexProgram._Current); 356 } 357 } 358 359 return new_state; 360} 361 362 363/** 364 * Examine shader constants and return either _NEW_PROGRAM_CONSTANTS or 0. 365 */ 366static GLbitfield 367update_program_constants(struct gl_context *ctx) 368{ 369 GLbitfield new_state = 0x0; 370 371 if (ctx->FragmentProgram._Current) { 372 const struct gl_program_parameter_list *params = 373 ctx->FragmentProgram._Current->Base.Parameters; 374 if (params && params->StateFlags & ctx->NewState) { 375 new_state |= _NEW_PROGRAM_CONSTANTS; 376 } 377 } 378 379 if (ctx->GeometryProgram._Current) { 380 const struct gl_program_parameter_list *params = 381 ctx->GeometryProgram._Current->Base.Parameters; 382 /*FIXME: StateFlags is always 0 because we have unnamed constant 383 * not state changes */ 384 if (params /*&& params->StateFlags & ctx->NewState*/) { 385 new_state |= _NEW_PROGRAM_CONSTANTS; 386 } 387 } 388 389 if (ctx->VertexProgram._Current) { 390 const struct gl_program_parameter_list *params = 391 ctx->VertexProgram._Current->Base.Parameters; 392 if (params && params->StateFlags & ctx->NewState) { 393 new_state |= _NEW_PROGRAM_CONSTANTS; 394 } 395 } 396 397 return new_state; 398} 399 400 401 402 403static void 404update_viewport_matrix(struct gl_context *ctx) 405{ 406 const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF; 407 408 ASSERT(depthMax > 0); 409 410 /* Compute scale and bias values. This is really driver-specific 411 * and should be maintained elsewhere if at all. 412 * NOTE: RasterPos uses this. 413 */ 414 _math_matrix_viewport(&ctx->Viewport._WindowMap, 415 ctx->Viewport.X, ctx->Viewport.Y, 416 ctx->Viewport.Width, ctx->Viewport.Height, 417 ctx->Viewport.Near, ctx->Viewport.Far, 418 depthMax); 419} 420 421 422/** 423 * Update derived multisample state. 424 */ 425static void 426update_multisample(struct gl_context *ctx) 427{ 428 ctx->Multisample._Enabled = GL_FALSE; 429 if (ctx->Multisample.Enabled && 430 ctx->DrawBuffer && 431 ctx->DrawBuffer->Visual.sampleBuffers) 432 ctx->Multisample._Enabled = GL_TRUE; 433} 434 435 436/** 437 * Update derived color/blend/logicop state. 438 */ 439static void 440update_color(struct gl_context *ctx) 441{ 442 /* This is needed to support 1.1's RGB logic ops AND 443 * 1.0's blending logicops. 444 */ 445 ctx->Color._LogicOpEnabled = _mesa_rgba_logicop_enabled(ctx); 446} 447 448 449/* 450 * Check polygon state and set DD_TRI_CULL_FRONT_BACK and/or DD_TRI_OFFSET 451 * in ctx->_TriangleCaps if needed. 452 */ 453static void 454update_polygon(struct gl_context *ctx) 455{ 456 ctx->_TriangleCaps &= ~(DD_TRI_CULL_FRONT_BACK | DD_TRI_OFFSET); 457 458 if (ctx->Polygon.CullFlag && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) 459 ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK; 460 461 if ( ctx->Polygon.OffsetPoint 462 || ctx->Polygon.OffsetLine 463 || ctx->Polygon.OffsetFill) 464 ctx->_TriangleCaps |= DD_TRI_OFFSET; 465} 466 467 468/** 469 * Update the ctx->_TriangleCaps bitfield. 470 * XXX that bitfield should really go away someday! 471 * This function must be called after other update_*() functions since 472 * there are dependencies on some other derived values. 473 */ 474#if 0 475static void 476update_tricaps(struct gl_context *ctx, GLbitfield new_state) 477{ 478 ctx->_TriangleCaps = 0; 479 480 /* 481 * Points 482 */ 483 if (1/*new_state & _NEW_POINT*/) { 484 if (ctx->Point.SmoothFlag) 485 ctx->_TriangleCaps |= DD_POINT_SMOOTH; 486 if (ctx->Point._Attenuated) 487 ctx->_TriangleCaps |= DD_POINT_ATTEN; 488 } 489 490 /* 491 * Lines 492 */ 493 if (1/*new_state & _NEW_LINE*/) { 494 if (ctx->Line.SmoothFlag) 495 ctx->_TriangleCaps |= DD_LINE_SMOOTH; 496 if (ctx->Line.StippleFlag) 497 ctx->_TriangleCaps |= DD_LINE_STIPPLE; 498 } 499 500 /* 501 * Polygons 502 */ 503 if (1/*new_state & _NEW_POLYGON*/) { 504 if (ctx->Polygon.SmoothFlag) 505 ctx->_TriangleCaps |= DD_TRI_SMOOTH; 506 if (ctx->Polygon.StippleFlag) 507 ctx->_TriangleCaps |= DD_TRI_STIPPLE; 508 if (ctx->Polygon.FrontMode != GL_FILL 509 || ctx->Polygon.BackMode != GL_FILL) 510 ctx->_TriangleCaps |= DD_TRI_UNFILLED; 511 if (ctx->Polygon.CullFlag 512 && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) 513 ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK; 514 if (ctx->Polygon.OffsetPoint || 515 ctx->Polygon.OffsetLine || 516 ctx->Polygon.OffsetFill) 517 ctx->_TriangleCaps |= DD_TRI_OFFSET; 518 } 519 520 /* 521 * Lighting and shading 522 */ 523 if (ctx->Light.Enabled && ctx->Light.Model.TwoSide) 524 ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE; 525 if (ctx->Light.ShadeModel == GL_FLAT) 526 ctx->_TriangleCaps |= DD_FLATSHADE; 527 if (_mesa_need_secondary_color(ctx)) 528 ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR; 529 530 /* 531 * Stencil 532 */ 533 if (ctx->Stencil._TestTwoSide) 534 ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL; 535} 536#endif 537 538 539/** 540 * Compute derived GL state. 541 * If __struct gl_contextRec::NewState is non-zero then this function \b must 542 * be called before rendering anything. 543 * 544 * Calls dd_function_table::UpdateState to perform any internal state 545 * management necessary. 546 * 547 * \sa _mesa_update_modelview_project(), _mesa_update_texture(), 548 * _mesa_update_buffer_bounds(), 549 * _mesa_update_lighting() and _mesa_update_tnl_spaces(). 550 */ 551void 552_mesa_update_state_locked( struct gl_context *ctx ) 553{ 554 GLbitfield new_state = ctx->NewState; 555 GLbitfield prog_flags = _NEW_PROGRAM; 556 GLbitfield new_prog_state = 0x0; 557 558 if (new_state == _NEW_CURRENT_ATTRIB) 559 goto out; 560 561 if (MESA_VERBOSE & VERBOSE_STATE) 562 _mesa_print_state("_mesa_update_state", new_state); 563 564 /* Determine which state flags effect vertex/fragment program state */ 565 if (ctx->FragmentProgram._MaintainTexEnvProgram) { 566 prog_flags |= (_NEW_BUFFERS | _NEW_TEXTURE | _NEW_FOG | 567 _NEW_ARRAY | _NEW_LIGHT | _NEW_POINT | _NEW_RENDERMODE | 568 _NEW_PROGRAM); 569 } 570 if (ctx->VertexProgram._MaintainTnlProgram) { 571 prog_flags |= (_NEW_ARRAY | _NEW_TEXTURE | _NEW_TEXTURE_MATRIX | 572 _NEW_TRANSFORM | _NEW_POINT | 573 _NEW_FOG | _NEW_LIGHT | 574 _MESA_NEW_NEED_EYE_COORDS); 575 } 576 577 /* 578 * Now update derived state info 579 */ 580 581 if (new_state & prog_flags) 582 update_program_enables( ctx ); 583 584 if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION)) 585 _mesa_update_modelview_project( ctx, new_state ); 586 587 if (new_state & (_NEW_PROGRAM|_NEW_TEXTURE|_NEW_TEXTURE_MATRIX)) 588 _mesa_update_texture( ctx, new_state ); 589 590 if (new_state & _NEW_BUFFERS) 591 _mesa_update_framebuffer(ctx); 592 593 if (new_state & (_NEW_SCISSOR | _NEW_BUFFERS | _NEW_VIEWPORT)) 594 _mesa_update_draw_buffer_bounds( ctx ); 595 596 if (new_state & _NEW_POLYGON) 597 update_polygon( ctx ); 598 599 if (new_state & _NEW_LIGHT) 600 _mesa_update_lighting( ctx ); 601 602 if (new_state & (_NEW_STENCIL | _NEW_BUFFERS)) 603 _mesa_update_stencil( ctx ); 604 605 if (new_state & _MESA_NEW_TRANSFER_STATE) 606 _mesa_update_pixel( ctx, new_state ); 607 608 if (new_state & _DD_NEW_SEPARATE_SPECULAR) 609 update_separate_specular( ctx ); 610 611 if (new_state & (_NEW_BUFFERS | _NEW_VIEWPORT)) 612 update_viewport_matrix(ctx); 613 614 if (new_state & _NEW_MULTISAMPLE) 615 update_multisample( ctx ); 616 617 if (new_state & _NEW_COLOR) 618 update_color( ctx ); 619 620#if 0 621 if (new_state & (_NEW_POINT | _NEW_LINE | _NEW_POLYGON | _NEW_LIGHT 622 | _NEW_STENCIL | _DD_NEW_SEPARATE_SPECULAR)) 623 update_tricaps( ctx, new_state ); 624#endif 625 626 /* ctx->_NeedEyeCoords is now up to date. 627 * 628 * If the truth value of this variable has changed, update for the 629 * new lighting space and recompute the positions of lights and the 630 * normal transform. 631 * 632 * If the lighting space hasn't changed, may still need to recompute 633 * light positions & normal transforms for other reasons. 634 */ 635 if (new_state & _MESA_NEW_NEED_EYE_COORDS) 636 _mesa_update_tnl_spaces( ctx, new_state ); 637 638 if (new_state & prog_flags) { 639 /* When we generate programs from fixed-function vertex/fragment state 640 * this call may generate/bind a new program. If so, we need to 641 * propogate the _NEW_PROGRAM flag to the driver. 642 */ 643 new_prog_state |= update_program( ctx ); 644 } 645 646 if (new_state & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT)) 647 update_arrays( ctx ); 648 649 out: 650 new_prog_state |= update_program_constants(ctx); 651 652 /* 653 * Give the driver a chance to act upon the new_state flags. 654 * The driver might plug in different span functions, for example. 655 * Also, this is where the driver can invalidate the state of any 656 * active modules (such as swrast_setup, swrast, tnl, etc). 657 * 658 * Set ctx->NewState to zero to avoid recursion if 659 * Driver.UpdateState() has to call FLUSH_VERTICES(). (fixed?) 660 */ 661 new_state = ctx->NewState | new_prog_state; 662 ctx->NewState = 0; 663 ctx->Driver.UpdateState(ctx, new_state); 664 ctx->Array.NewState = 0; 665 if (!ctx->Array.RebindArrays) 666 ctx->Array.RebindArrays = (new_state & (_NEW_ARRAY | _NEW_PROGRAM)) != 0; 667} 668 669 670/* This is the usual entrypoint for state updates: 671 */ 672void 673_mesa_update_state( struct gl_context *ctx ) 674{ 675 _mesa_lock_context_textures(ctx); 676 _mesa_update_state_locked(ctx); 677 _mesa_unlock_context_textures(ctx); 678} 679 680 681 682 683/** 684 * Want to figure out which fragment program inputs are actually 685 * constant/current values from ctx->Current. These should be 686 * referenced as a tracked state variable rather than a fragment 687 * program input, to save the overhead of putting a constant value in 688 * every submitted vertex, transferring it to hardware, interpolating 689 * it across the triangle, etc... 690 * 691 * When there is a VP bound, just use vp->outputs. But when we're 692 * generating vp from fixed function state, basically want to 693 * calculate: 694 * 695 * vp_out_2_fp_in( vp_in_2_vp_out( varying_inputs ) | 696 * potential_vp_outputs ) 697 * 698 * Where potential_vp_outputs is calculated by looking at enabled 699 * texgen, etc. 700 * 701 * The generated fragment program should then only declare inputs that 702 * may vary or otherwise differ from the ctx->Current values. 703 * Otherwise, the fp should track them as state values instead. 704 */ 705void 706_mesa_set_varying_vp_inputs( struct gl_context *ctx, 707 GLbitfield varying_inputs ) 708{ 709 if (ctx->varying_vp_inputs != varying_inputs) { 710 ctx->varying_vp_inputs = varying_inputs; 711 ctx->NewState |= _NEW_ARRAY; 712 /*printf("%s %x\n", __FUNCTION__, varying_inputs);*/ 713 } 714} 715 716 717/** 718 * Used by drivers to tell core Mesa that the driver is going to 719 * install/ use its own vertex program. In particular, this will 720 * prevent generated fragment programs from using state vars instead 721 * of ordinary varyings/inputs. 722 */ 723void 724_mesa_set_vp_override(struct gl_context *ctx, GLboolean flag) 725{ 726 if (ctx->VertexProgram._Overriden != flag) { 727 ctx->VertexProgram._Overriden = flag; 728 729 /* Set one of the bits which will trigger fragment program 730 * regeneration: 731 */ 732 ctx->NewState |= _NEW_PROGRAM; 733 } 734} 735