state.c revision ec2b92f98c2e7f161521b447cc1d9a36bce3707c
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 GLcontext. 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(GLcontext *ctx) 55{ 56 if (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( GLcontext *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(GLcontext *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(GLcontext *ctx) 249{ 250 const struct gl_shader_program *shProg = ctx->Shader.CurrentProgram; 251 const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current; 252 const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current; 253 GLbitfield new_state = 0x0; 254 255 /* 256 * Set the ctx->VertexProgram._Current and ctx->FragmentProgram._Current 257 * pointers to the programs that should be used for rendering. If either 258 * is NULL, use fixed-function code paths. 259 * 260 * These programs may come from several sources. The priority is as 261 * follows: 262 * 1. OpenGL 2.0/ARB vertex/fragment shaders 263 * 2. ARB/NV vertex/fragment programs 264 * 3. Programs derived from fixed-function state. 265 * 266 * Note: it's possible for a vertex shader to get used with a fragment 267 * program (and vice versa) here, but in practice that shouldn't ever 268 * come up, or matter. 269 */ 270 271 if (shProg && shProg->LinkStatus && shProg->FragmentProgram) { 272 /* Use shader programs */ 273 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, 274 shProg->FragmentProgram); 275 } 276 else if (ctx->FragmentProgram._Enabled) { 277 /* use user-defined vertex program */ 278 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, 279 ctx->FragmentProgram.Current); 280 } 281 else if (ctx->FragmentProgram._MaintainTexEnvProgram) { 282 /* Use fragment program generated from fixed-function state. 283 */ 284 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, 285 _mesa_get_fixed_func_fragment_program(ctx)); 286 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, 287 ctx->FragmentProgram._Current); 288 } 289 else { 290 /* no fragment program */ 291 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL); 292 } 293 294 /* Examine vertex program after fragment program as 295 * _mesa_get_fixed_func_vertex_program() needs to know active 296 * fragprog inputs. 297 */ 298 if (shProg && shProg->LinkStatus && shProg->VertexProgram) { 299 /* Use shader programs */ 300 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, 301 shProg->VertexProgram); 302 } 303 else if (ctx->VertexProgram._Enabled) { 304 /* use user-defined vertex program */ 305 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, 306 ctx->VertexProgram.Current); 307 } 308 else if (ctx->VertexProgram._MaintainTnlProgram) { 309 /* Use vertex program generated from fixed-function state. 310 */ 311 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, 312 _mesa_get_fixed_func_vertex_program(ctx)); 313 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, 314 ctx->VertexProgram._Current); 315 } 316 else { 317 /* no vertex program */ 318 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL); 319 } 320 321 /* Let the driver know what's happening: 322 */ 323 if (ctx->FragmentProgram._Current != prevFP) { 324 new_state |= _NEW_PROGRAM; 325 if (ctx->Driver.BindProgram) { 326 ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 327 (struct gl_program *) ctx->FragmentProgram._Current); 328 } 329 } 330 331 if (ctx->VertexProgram._Current != prevVP) { 332 new_state |= _NEW_PROGRAM; 333 if (ctx->Driver.BindProgram) { 334 ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB, 335 (struct gl_program *) ctx->VertexProgram._Current); 336 } 337 } 338 339 return new_state; 340} 341 342 343/** 344 * Examine shader constants and return either _NEW_PROGRAM_CONSTANTS or 0. 345 */ 346static GLbitfield 347update_program_constants(GLcontext *ctx) 348{ 349 GLbitfield new_state = 0x0; 350 351 if (ctx->FragmentProgram._Current) { 352 const struct gl_program_parameter_list *params = 353 ctx->FragmentProgram._Current->Base.Parameters; 354 if (params && params->StateFlags & ctx->NewState) { 355 new_state |= _NEW_PROGRAM_CONSTANTS; 356 } 357 } 358 359 if (ctx->VertexProgram._Current) { 360 const struct gl_program_parameter_list *params = 361 ctx->VertexProgram._Current->Base.Parameters; 362 if (params && params->StateFlags & ctx->NewState) { 363 new_state |= _NEW_PROGRAM_CONSTANTS; 364 } 365 } 366 367 return new_state; 368} 369 370 371 372 373static void 374update_viewport_matrix(GLcontext *ctx) 375{ 376 const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF; 377 378 ASSERT(depthMax > 0); 379 380 /* Compute scale and bias values. This is really driver-specific 381 * and should be maintained elsewhere if at all. 382 * NOTE: RasterPos uses this. 383 */ 384 _math_matrix_viewport(&ctx->Viewport._WindowMap, 385 ctx->Viewport.X, ctx->Viewport.Y, 386 ctx->Viewport.Width, ctx->Viewport.Height, 387 ctx->Viewport.Near, ctx->Viewport.Far, 388 depthMax); 389} 390 391 392/** 393 * Update derived multisample state. 394 */ 395static void 396update_multisample(GLcontext *ctx) 397{ 398 ctx->Multisample._Enabled = GL_FALSE; 399 if (ctx->Multisample.Enabled && 400 ctx->DrawBuffer && 401 ctx->DrawBuffer->Visual.sampleBuffers) 402 ctx->Multisample._Enabled = GL_TRUE; 403} 404 405 406/** 407 * Update derived color/blend/logicop state. 408 */ 409static void 410update_color(GLcontext *ctx) 411{ 412 /* This is needed to support 1.1's RGB logic ops AND 413 * 1.0's blending logicops. 414 */ 415 ctx->Color._LogicOpEnabled = RGBA_LOGICOP_ENABLED(ctx); 416} 417 418 419/* 420 * Check polygon state and set DD_TRI_CULL_FRONT_BACK and/or DD_TRI_OFFSET 421 * in ctx->_TriangleCaps if needed. 422 */ 423static void 424update_polygon(GLcontext *ctx) 425{ 426 ctx->_TriangleCaps &= ~(DD_TRI_CULL_FRONT_BACK | DD_TRI_OFFSET); 427 428 if (ctx->Polygon.CullFlag && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) 429 ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK; 430 431 if ( ctx->Polygon.OffsetPoint 432 || ctx->Polygon.OffsetLine 433 || ctx->Polygon.OffsetFill) 434 ctx->_TriangleCaps |= DD_TRI_OFFSET; 435} 436 437 438/** 439 * Update the ctx->_TriangleCaps bitfield. 440 * XXX that bitfield should really go away someday! 441 * This function must be called after other update_*() functions since 442 * there are dependencies on some other derived values. 443 */ 444#if 0 445static void 446update_tricaps(GLcontext *ctx, GLbitfield new_state) 447{ 448 ctx->_TriangleCaps = 0; 449 450 /* 451 * Points 452 */ 453 if (1/*new_state & _NEW_POINT*/) { 454 if (ctx->Point.SmoothFlag) 455 ctx->_TriangleCaps |= DD_POINT_SMOOTH; 456 if (ctx->Point.Size != 1.0F) 457 ctx->_TriangleCaps |= DD_POINT_SIZE; 458 if (ctx->Point._Attenuated) 459 ctx->_TriangleCaps |= DD_POINT_ATTEN; 460 } 461 462 /* 463 * Lines 464 */ 465 if (1/*new_state & _NEW_LINE*/) { 466 if (ctx->Line.SmoothFlag) 467 ctx->_TriangleCaps |= DD_LINE_SMOOTH; 468 if (ctx->Line.StippleFlag) 469 ctx->_TriangleCaps |= DD_LINE_STIPPLE; 470 if (ctx->Line.Width != 1.0) 471 ctx->_TriangleCaps |= DD_LINE_WIDTH; 472 } 473 474 /* 475 * Polygons 476 */ 477 if (1/*new_state & _NEW_POLYGON*/) { 478 if (ctx->Polygon.SmoothFlag) 479 ctx->_TriangleCaps |= DD_TRI_SMOOTH; 480 if (ctx->Polygon.StippleFlag) 481 ctx->_TriangleCaps |= DD_TRI_STIPPLE; 482 if (ctx->Polygon.FrontMode != GL_FILL 483 || ctx->Polygon.BackMode != GL_FILL) 484 ctx->_TriangleCaps |= DD_TRI_UNFILLED; 485 if (ctx->Polygon.CullFlag 486 && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) 487 ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK; 488 if (ctx->Polygon.OffsetPoint || 489 ctx->Polygon.OffsetLine || 490 ctx->Polygon.OffsetFill) 491 ctx->_TriangleCaps |= DD_TRI_OFFSET; 492 } 493 494 /* 495 * Lighting and shading 496 */ 497 if (ctx->Light.Enabled && ctx->Light.Model.TwoSide) 498 ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE; 499 if (ctx->Light.ShadeModel == GL_FLAT) 500 ctx->_TriangleCaps |= DD_FLATSHADE; 501 if (NEED_SECONDARY_COLOR(ctx)) 502 ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR; 503 504 /* 505 * Stencil 506 */ 507 if (ctx->Stencil._TestTwoSide) 508 ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL; 509} 510#endif 511 512 513/** 514 * Compute derived GL state. 515 * If __GLcontextRec::NewState is non-zero then this function \b must 516 * be called before rendering anything. 517 * 518 * Calls dd_function_table::UpdateState to perform any internal state 519 * management necessary. 520 * 521 * \sa _mesa_update_modelview_project(), _mesa_update_texture(), 522 * _mesa_update_buffer_bounds(), 523 * _mesa_update_lighting() and _mesa_update_tnl_spaces(). 524 */ 525void 526_mesa_update_state_locked( GLcontext *ctx ) 527{ 528 GLbitfield new_state = ctx->NewState; 529 GLbitfield prog_flags = _NEW_PROGRAM; 530 GLbitfield new_prog_state = 0x0; 531 532 if (new_state == _NEW_CURRENT_ATTRIB) 533 goto out; 534 535 if (MESA_VERBOSE & VERBOSE_STATE) 536 _mesa_print_state("_mesa_update_state", new_state); 537 538 /* Determine which state flags effect vertex/fragment program state */ 539 if (ctx->FragmentProgram._MaintainTexEnvProgram) { 540 prog_flags |= (_NEW_TEXTURE | _NEW_FOG | 541 _NEW_ARRAY | _NEW_LIGHT | _NEW_POINT | _NEW_RENDERMODE | 542 _NEW_PROGRAM); 543 } 544 if (ctx->VertexProgram._MaintainTnlProgram) { 545 prog_flags |= (_NEW_ARRAY | _NEW_TEXTURE | _NEW_TEXTURE_MATRIX | 546 _NEW_TRANSFORM | _NEW_POINT | 547 _NEW_FOG | _NEW_LIGHT | 548 _MESA_NEW_NEED_EYE_COORDS); 549 } 550 551 /* 552 * Now update derived state info 553 */ 554 555 if (new_state & prog_flags) 556 update_program_enables( ctx ); 557 558 if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION)) 559 _mesa_update_modelview_project( ctx, new_state ); 560 561 if (new_state & (_NEW_PROGRAM|_NEW_TEXTURE|_NEW_TEXTURE_MATRIX)) 562 _mesa_update_texture( ctx, new_state ); 563 564 if (new_state & _NEW_BUFFERS) 565 _mesa_update_framebuffer(ctx); 566 567 if (new_state & (_NEW_SCISSOR | _NEW_BUFFERS | _NEW_VIEWPORT)) 568 _mesa_update_draw_buffer_bounds( ctx ); 569 570 if (new_state & _NEW_POLYGON) 571 update_polygon( ctx ); 572 573 if (new_state & _NEW_LIGHT) 574 _mesa_update_lighting( ctx ); 575 576 if (new_state & (_NEW_STENCIL | _NEW_BUFFERS)) 577 _mesa_update_stencil( ctx ); 578 579 if (new_state & _MESA_NEW_TRANSFER_STATE) 580 _mesa_update_pixel( ctx, new_state ); 581 582 if (new_state & _DD_NEW_SEPARATE_SPECULAR) 583 update_separate_specular( ctx ); 584 585 if (new_state & (_NEW_BUFFERS | _NEW_VIEWPORT)) 586 update_viewport_matrix(ctx); 587 588 if (new_state & _NEW_MULTISAMPLE) 589 update_multisample( ctx ); 590 591 if (new_state & _NEW_COLOR) 592 update_color( ctx ); 593 594#if 0 595 if (new_state & (_NEW_POINT | _NEW_LINE | _NEW_POLYGON | _NEW_LIGHT 596 | _NEW_STENCIL | _DD_NEW_SEPARATE_SPECULAR)) 597 update_tricaps( ctx, new_state ); 598#endif 599 600 /* ctx->_NeedEyeCoords is now up to date. 601 * 602 * If the truth value of this variable has changed, update for the 603 * new lighting space and recompute the positions of lights and the 604 * normal transform. 605 * 606 * If the lighting space hasn't changed, may still need to recompute 607 * light positions & normal transforms for other reasons. 608 */ 609 if (new_state & _MESA_NEW_NEED_EYE_COORDS) 610 _mesa_update_tnl_spaces( ctx, new_state ); 611 612 if (new_state & prog_flags) { 613 /* When we generate programs from fixed-function vertex/fragment state 614 * this call may generate/bind a new program. If so, we need to 615 * propogate the _NEW_PROGRAM flag to the driver. 616 */ 617 new_prog_state |= update_program( ctx ); 618 } 619 620 if (new_state & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT)) 621 update_arrays( ctx ); 622 623 out: 624 new_prog_state |= update_program_constants(ctx); 625 626 /* 627 * Give the driver a chance to act upon the new_state flags. 628 * The driver might plug in different span functions, for example. 629 * Also, this is where the driver can invalidate the state of any 630 * active modules (such as swrast_setup, swrast, tnl, etc). 631 * 632 * Set ctx->NewState to zero to avoid recursion if 633 * Driver.UpdateState() has to call FLUSH_VERTICES(). (fixed?) 634 */ 635 new_state = ctx->NewState | new_prog_state; 636 ctx->NewState = 0; 637 ctx->Driver.UpdateState(ctx, new_state); 638 ctx->Array.NewState = 0; 639} 640 641 642/* This is the usual entrypoint for state updates: 643 */ 644void 645_mesa_update_state( GLcontext *ctx ) 646{ 647 _mesa_lock_context_textures(ctx); 648 _mesa_update_state_locked(ctx); 649 _mesa_unlock_context_textures(ctx); 650} 651 652 653 654 655/** 656 * Want to figure out which fragment program inputs are actually 657 * constant/current values from ctx->Current. These should be 658 * referenced as a tracked state variable rather than a fragment 659 * program input, to save the overhead of putting a constant value in 660 * every submitted vertex, transferring it to hardware, interpolating 661 * it across the triangle, etc... 662 * 663 * When there is a VP bound, just use vp->outputs. But when we're 664 * generating vp from fixed function state, basically want to 665 * calculate: 666 * 667 * vp_out_2_fp_in( vp_in_2_vp_out( varying_inputs ) | 668 * potential_vp_outputs ) 669 * 670 * Where potential_vp_outputs is calculated by looking at enabled 671 * texgen, etc. 672 * 673 * The generated fragment program should then only declare inputs that 674 * may vary or otherwise differ from the ctx->Current values. 675 * Otherwise, the fp should track them as state values instead. 676 */ 677void 678_mesa_set_varying_vp_inputs( GLcontext *ctx, 679 GLbitfield varying_inputs ) 680{ 681 if (ctx->varying_vp_inputs != varying_inputs) { 682 ctx->varying_vp_inputs = varying_inputs; 683 ctx->NewState |= _NEW_ARRAY; 684 /*printf("%s %x\n", __FUNCTION__, varying_inputs);*/ 685 } 686} 687 688 689/** 690 * Used by drivers to tell core Mesa that the driver is going to 691 * install/ use its own vertex program. In particular, this will 692 * prevent generated fragment programs from using state vars instead 693 * of ordinary varyings/inputs. 694 */ 695void 696_mesa_set_vp_override(GLcontext *ctx, GLboolean flag) 697{ 698 if (ctx->VertexProgram._Overriden != flag) { 699 ctx->VertexProgram._Overriden = flag; 700 701 /* Set one of the bits which will trigger fragment program 702 * regeneration: 703 */ 704 ctx->NewState |= _NEW_PROGRAM; 705 } 706} 707