state.c revision a4a5a37f2760eca97b85f699c932c746da4d8e6c
1/* 2 * Mesa 3-D graphics library 3 * Version: 7.1 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#if FEATURE_pixel_transfer 44#include "pixel.h" 45#endif 46#include "shader/program.h" 47#include "state.h" 48#include "stencil.h" 49#include "texenvprogram.h" 50#include "texobj.h" 51#include "texstate.h" 52 53 54static void 55update_separate_specular(GLcontext *ctx) 56{ 57 if (NEED_SECONDARY_COLOR(ctx)) 58 ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR; 59 else 60 ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR; 61} 62 63 64/** 65 * Update state dependent on vertex arrays. 66 */ 67static void 68update_arrays( GLcontext *ctx ) 69{ 70 GLuint i, min; 71 72 /* find min of _MaxElement values for all enabled arrays */ 73 74 /* 0 */ 75 if (ctx->VertexProgram._Current 76 && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) { 77 min = ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS]._MaxElement; 78 } 79 else if (ctx->Array.ArrayObj->Vertex.Enabled) { 80 min = ctx->Array.ArrayObj->Vertex._MaxElement; 81 } 82 else { 83 /* can't draw anything without vertex positions! */ 84 min = 0; 85 } 86 87 /* 1 */ 88 if (ctx->VertexProgram._Enabled 89 && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT].Enabled) { 90 min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT]._MaxElement); 91 } 92 /* no conventional vertex weight array */ 93 94 /* 2 */ 95 if (ctx->VertexProgram._Enabled 96 && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) { 97 min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]._MaxElement); 98 } 99 else if (ctx->Array.ArrayObj->Normal.Enabled) { 100 min = MIN2(min, ctx->Array.ArrayObj->Normal._MaxElement); 101 } 102 103 /* 3 */ 104 if (ctx->VertexProgram._Enabled 105 && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) { 106 min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]._MaxElement); 107 } 108 else if (ctx->Array.ArrayObj->Color.Enabled) { 109 min = MIN2(min, ctx->Array.ArrayObj->Color._MaxElement); 110 } 111 112 /* 4 */ 113 if (ctx->VertexProgram._Enabled 114 && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) { 115 min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR1]._MaxElement); 116 } 117 else if (ctx->Array.ArrayObj->SecondaryColor.Enabled) { 118 min = MIN2(min, ctx->Array.ArrayObj->SecondaryColor._MaxElement); 119 } 120 121 /* 5 */ 122 if (ctx->VertexProgram._Enabled 123 && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) { 124 min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_FOG]._MaxElement); 125 } 126 else if (ctx->Array.ArrayObj->FogCoord.Enabled) { 127 min = MIN2(min, ctx->Array.ArrayObj->FogCoord._MaxElement); 128 } 129 130 /* 6 */ 131 if (ctx->VertexProgram._Enabled 132 && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) { 133 min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]._MaxElement); 134 } 135 else if (ctx->Array.ArrayObj->Index.Enabled) { 136 min = MIN2(min, ctx->Array.ArrayObj->Index._MaxElement); 137 } 138 139 140 /* 7 */ 141 if (ctx->VertexProgram._Enabled 142 && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) { 143 min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG]._MaxElement); 144 } 145 146 /* 8..15 */ 147 for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX7; i++) { 148 if (ctx->VertexProgram._Enabled 149 && ctx->Array.ArrayObj->VertexAttrib[i].Enabled) { 150 min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[i]._MaxElement); 151 } 152 else if (i - VERT_ATTRIB_TEX0 < ctx->Const.MaxTextureCoordUnits 153 && ctx->Array.ArrayObj->TexCoord[i - VERT_ATTRIB_TEX0].Enabled) { 154 min = MIN2(min, ctx->Array.ArrayObj->TexCoord[i - VERT_ATTRIB_TEX0]._MaxElement); 155 } 156 } 157 158 /* 16..31 */ 159 if (ctx->VertexProgram._Current) { 160 for (i = VERT_ATTRIB_GENERIC0; i < VERT_ATTRIB_MAX; i++) { 161 if (ctx->Array.ArrayObj->VertexAttrib[i].Enabled) { 162 min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[i]._MaxElement); 163 } 164 } 165 } 166 167 if (ctx->Array.ArrayObj->EdgeFlag.Enabled) { 168 min = MIN2(min, ctx->Array.ArrayObj->EdgeFlag._MaxElement); 169 } 170 171 /* _MaxElement is one past the last legal array element */ 172 ctx->Array._MaxElement = min; 173} 174 175 176static void 177update_program(GLcontext *ctx) 178{ 179 const struct gl_shader_program *shProg = ctx->Shader.CurrentProgram; 180 const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current; 181 const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current; 182 183 /* These _Enabled flags indicate if the program is enabled AND valid. */ 184 ctx->VertexProgram._Enabled = ctx->VertexProgram.Enabled 185 && ctx->VertexProgram.Current->Base.Instructions; 186 ctx->FragmentProgram._Enabled = ctx->FragmentProgram.Enabled 187 && ctx->FragmentProgram.Current->Base.Instructions; 188 ctx->ATIFragmentShader._Enabled = ctx->ATIFragmentShader.Enabled 189 && ctx->ATIFragmentShader.Current->Instructions[0]; 190 191 /* 192 * Set the ctx->VertexProgram._Current and ctx->FragmentProgram._Current 193 * pointers to the programs that should be enabled/used. These will only 194 * be NULL if we need to use the fixed-function code. 195 * 196 * These programs may come from several sources. The priority is as 197 * follows: 198 * 1. OpenGL 2.0/ARB vertex/fragment shaders 199 * 2. ARB/NV vertex/fragment programs 200 * 3. Programs derived from fixed-function state. 201 * 202 * Note: it's possible for a vertex shader to get used with a fragment 203 * program (and vice versa) here, but in practice that shouldn't ever 204 * come up, or matter. 205 */ 206 207 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL); 208 209 if (shProg && shProg->LinkStatus) { 210 /* Use shader programs */ 211 /* XXX this isn't quite right, since we may have either a vertex 212 * _or_ fragment shader (not always both). 213 */ 214 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, 215 shProg->VertexProgram); 216 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, 217 shProg->FragmentProgram); 218 } 219 else { 220 if (ctx->FragmentProgram._Enabled) { 221 /* use user-defined vertex program */ 222 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, 223 ctx->FragmentProgram.Current); 224 } 225 else if (ctx->FragmentProgram._MaintainTexEnvProgram) { 226 /* Use fragment program generated from fixed-function state. 227 */ 228 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, 229 _mesa_get_fixed_func_fragment_program(ctx)); 230 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, 231 ctx->FragmentProgram._Current); 232 } 233 else { 234 /* no fragment program */ 235 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL); 236 } 237 238 /* Examine vertex program after fragment program as 239 * _mesa_get_fixed_func_vertex_program() needs to know active 240 * fragprog inputs. 241 */ 242 if (ctx->VertexProgram._Enabled) { 243 /* use user-defined vertex program */ 244 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, 245 ctx->VertexProgram.Current); 246 } 247 else if (ctx->VertexProgram._MaintainTnlProgram) { 248 /* Use vertex program generated from fixed-function state. 249 */ 250 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, 251 _mesa_get_fixed_func_vertex_program(ctx)); 252 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, 253 ctx->VertexProgram._Current); 254 } 255 else { 256 /* no vertex program */ 257 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL); 258 } 259 } 260 261 /* XXX: get rid of _Active flag. 262 */ 263#if 1 264 ctx->FragmentProgram._Active = ctx->FragmentProgram._Enabled; 265 if (ctx->FragmentProgram._MaintainTexEnvProgram && 266 !ctx->FragmentProgram._Enabled) { 267 if (ctx->FragmentProgram._UseTexEnvProgram) 268 ctx->FragmentProgram._Active = GL_TRUE; 269 } 270#endif 271 272 /* Let the driver know what's happening: 273 */ 274 if (ctx->FragmentProgram._Current != prevFP && ctx->Driver.BindProgram) { 275 ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 276 (struct gl_program *) ctx->FragmentProgram._Current); 277 } 278 279 if (ctx->VertexProgram._Current != prevVP && ctx->Driver.BindProgram) { 280 ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB, 281 (struct gl_program *) ctx->VertexProgram._Current); 282 } 283} 284 285 286static void 287update_viewport_matrix(GLcontext *ctx) 288{ 289 const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF; 290 291 ASSERT(depthMax > 0); 292 293 /* Compute scale and bias values. This is really driver-specific 294 * and should be maintained elsewhere if at all. 295 * NOTE: RasterPos uses this. 296 */ 297 _math_matrix_viewport(&ctx->Viewport._WindowMap, 298 ctx->Viewport.X, ctx->Viewport.Y, 299 ctx->Viewport.Width, ctx->Viewport.Height, 300 ctx->Viewport.Near, ctx->Viewport.Far, 301 depthMax); 302} 303 304 305/** 306 * Update derived multisample state. 307 */ 308static void 309update_multisample(GLcontext *ctx) 310{ 311 ctx->Multisample._Enabled = GL_FALSE; 312 if (ctx->Multisample.Enabled && 313 ctx->DrawBuffer && 314 ctx->DrawBuffer->Visual.sampleBuffers) 315 ctx->Multisample._Enabled = GL_TRUE; 316} 317 318 319/** 320 * Update derived color/blend/logicop state. 321 */ 322static void 323update_color(GLcontext *ctx) 324{ 325 /* This is needed to support 1.1's RGB logic ops AND 326 * 1.0's blending logicops. 327 */ 328 ctx->Color._LogicOpEnabled = RGBA_LOGICOP_ENABLED(ctx); 329} 330 331 332/* 333 * Check polygon state and set DD_TRI_CULL_FRONT_BACK and/or DD_TRI_OFFSET 334 * in ctx->_TriangleCaps if needed. 335 */ 336static void 337update_polygon(GLcontext *ctx) 338{ 339 ctx->_TriangleCaps &= ~(DD_TRI_CULL_FRONT_BACK | DD_TRI_OFFSET); 340 341 if (ctx->Polygon.CullFlag && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) 342 ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK; 343 344 if ( ctx->Polygon.OffsetPoint 345 || ctx->Polygon.OffsetLine 346 || ctx->Polygon.OffsetFill) 347 ctx->_TriangleCaps |= DD_TRI_OFFSET; 348} 349 350 351/** 352 * Update the ctx->_TriangleCaps bitfield. 353 * XXX that bitfield should really go away someday! 354 * This function must be called after other update_*() functions since 355 * there are dependencies on some other derived values. 356 */ 357#if 0 358static void 359update_tricaps(GLcontext *ctx, GLbitfield new_state) 360{ 361 ctx->_TriangleCaps = 0; 362 363 /* 364 * Points 365 */ 366 if (1/*new_state & _NEW_POINT*/) { 367 if (ctx->Point.SmoothFlag) 368 ctx->_TriangleCaps |= DD_POINT_SMOOTH; 369 if (ctx->Point.Size != 1.0F) 370 ctx->_TriangleCaps |= DD_POINT_SIZE; 371 if (ctx->Point._Attenuated) 372 ctx->_TriangleCaps |= DD_POINT_ATTEN; 373 } 374 375 /* 376 * Lines 377 */ 378 if (1/*new_state & _NEW_LINE*/) { 379 if (ctx->Line.SmoothFlag) 380 ctx->_TriangleCaps |= DD_LINE_SMOOTH; 381 if (ctx->Line.StippleFlag) 382 ctx->_TriangleCaps |= DD_LINE_STIPPLE; 383 if (ctx->Line.Width != 1.0) 384 ctx->_TriangleCaps |= DD_LINE_WIDTH; 385 } 386 387 /* 388 * Polygons 389 */ 390 if (1/*new_state & _NEW_POLYGON*/) { 391 if (ctx->Polygon.SmoothFlag) 392 ctx->_TriangleCaps |= DD_TRI_SMOOTH; 393 if (ctx->Polygon.StippleFlag) 394 ctx->_TriangleCaps |= DD_TRI_STIPPLE; 395 if (ctx->Polygon.FrontMode != GL_FILL 396 || ctx->Polygon.BackMode != GL_FILL) 397 ctx->_TriangleCaps |= DD_TRI_UNFILLED; 398 if (ctx->Polygon.CullFlag 399 && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) 400 ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK; 401 if (ctx->Polygon.OffsetPoint || 402 ctx->Polygon.OffsetLine || 403 ctx->Polygon.OffsetFill) 404 ctx->_TriangleCaps |= DD_TRI_OFFSET; 405 } 406 407 /* 408 * Lighting and shading 409 */ 410 if (ctx->Light.Enabled && ctx->Light.Model.TwoSide) 411 ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE; 412 if (ctx->Light.ShadeModel == GL_FLAT) 413 ctx->_TriangleCaps |= DD_FLATSHADE; 414 if (NEED_SECONDARY_COLOR(ctx)) 415 ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR; 416 417 /* 418 * Stencil 419 */ 420 if (ctx->Stencil._TestTwoSide) 421 ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL; 422} 423#endif 424 425 426/** 427 * Compute derived GL state. 428 * If __GLcontextRec::NewState is non-zero then this function \b must 429 * be called before rendering anything. 430 * 431 * Calls dd_function_table::UpdateState to perform any internal state 432 * management necessary. 433 * 434 * \sa _mesa_update_modelview_project(), _mesa_update_texture(), 435 * _mesa_update_buffer_bounds(), 436 * _mesa_update_lighting() and _mesa_update_tnl_spaces(). 437 */ 438void 439_mesa_update_state_locked( GLcontext *ctx ) 440{ 441 GLbitfield new_state = ctx->NewState; 442 GLbitfield prog_flags = _NEW_PROGRAM; 443 444 if (MESA_VERBOSE & VERBOSE_STATE) 445 _mesa_print_state("_mesa_update_state", new_state); 446 447 if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION)) 448 _mesa_update_modelview_project( ctx, new_state ); 449 450 if (new_state & (_NEW_PROGRAM|_NEW_TEXTURE|_NEW_TEXTURE_MATRIX)) 451 _mesa_update_texture( ctx, new_state ); 452 453 if (new_state & (_NEW_BUFFERS | _NEW_COLOR | _NEW_PIXEL)) 454 _mesa_update_framebuffer(ctx); 455 456 if (new_state & (_NEW_SCISSOR | _NEW_BUFFERS | _NEW_VIEWPORT)) 457 _mesa_update_draw_buffer_bounds( ctx ); 458 459 if (new_state & _NEW_POLYGON) 460 update_polygon( ctx ); 461 462 if (new_state & _NEW_LIGHT) 463 _mesa_update_lighting( ctx ); 464 465 if (new_state & _NEW_STENCIL) 466 _mesa_update_stencil( ctx ); 467 468#if FEATURE_pixel_transfer 469 if (new_state & _IMAGE_NEW_TRANSFER_STATE) 470 _mesa_update_pixel( ctx, new_state ); 471#endif 472 473 if (new_state & _DD_NEW_SEPARATE_SPECULAR) 474 update_separate_specular( ctx ); 475 476 if (new_state & (_NEW_ARRAY | _NEW_PROGRAM)) 477 update_arrays( ctx ); 478 479 if (new_state & (_NEW_BUFFERS | _NEW_VIEWPORT)) 480 update_viewport_matrix(ctx); 481 482 if (new_state & _NEW_MULTISAMPLE) 483 update_multisample( ctx ); 484 485 if (new_state & _NEW_COLOR) 486 update_color( ctx ); 487 488#if 0 489 if (new_state & (_NEW_POINT | _NEW_LINE | _NEW_POLYGON | _NEW_LIGHT 490 | _NEW_STENCIL | _DD_NEW_SEPARATE_SPECULAR)) 491 update_tricaps( ctx, new_state ); 492#endif 493 494 /* ctx->_NeedEyeCoords is now up to date. 495 * 496 * If the truth value of this variable has changed, update for the 497 * new lighting space and recompute the positions of lights and the 498 * normal transform. 499 * 500 * If the lighting space hasn't changed, may still need to recompute 501 * light positions & normal transforms for other reasons. 502 */ 503 if (new_state & _MESA_NEW_NEED_EYE_COORDS) 504 _mesa_update_tnl_spaces( ctx, new_state ); 505 506 if (ctx->FragmentProgram._MaintainTexEnvProgram) { 507 prog_flags |= (_NEW_TEXTURE | _NEW_FOG | _DD_NEW_SEPARATE_SPECULAR); 508 } 509 if (ctx->VertexProgram._MaintainTnlProgram) { 510 prog_flags |= (_NEW_ARRAY | _NEW_TEXTURE | _NEW_TEXTURE_MATRIX | 511 _NEW_TRANSFORM | _NEW_POINT | 512 _NEW_FOG | _NEW_LIGHT | 513 _MESA_NEW_NEED_EYE_COORDS); 514 } 515 if (new_state & prog_flags) 516 update_program( ctx ); 517 518 519 520 /* 521 * Give the driver a chance to act upon the new_state flags. 522 * The driver might plug in different span functions, for example. 523 * Also, this is where the driver can invalidate the state of any 524 * active modules (such as swrast_setup, swrast, tnl, etc). 525 * 526 * Set ctx->NewState to zero to avoid recursion if 527 * Driver.UpdateState() has to call FLUSH_VERTICES(). (fixed?) 528 */ 529 new_state = ctx->NewState; 530 ctx->NewState = 0; 531 ctx->Driver.UpdateState(ctx, new_state); 532 ctx->Array.NewState = 0; 533} 534 535 536/* This is the usual entrypoint for state updates: 537 */ 538void 539_mesa_update_state( GLcontext *ctx ) 540{ 541 _mesa_lock_context_textures(ctx); 542 _mesa_update_state_locked(ctx); 543 _mesa_unlock_context_textures(ctx); 544} 545