1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included 14 * in all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 * 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 "arrayobj.h" 37 #include "context.h" 38 #include "debug.h" 39 #include "macros.h" 40 #include "ffvertex_prog.h" 41 #include "framebuffer.h" 42 #include "light.h" 43 #include "matrix.h" 44 #include "pixel.h" 45 #include "program/program.h" 46 #include "program/prog_parameter.h" 47 #include "shaderobj.h" 48 #include "state.h" 49 #include "stencil.h" 50 #include "texenvprogram.h" 51 #include "texobj.h" 52 #include "texstate.h" 53 #include "varray.h" 54 #include "vbo/vbo_context.h" 55 #include "viewport.h" 56 #include "blend.h" 57 58 59 /** 60 * Update the ctx->*Program._Current pointers to point to the 61 * current/active programs. 62 * 63 * Programs may come from 3 sources: GLSL shaders, ARB/NV_vertex/fragment 64 * programs or programs derived from fixed-function state. 65 * 66 * This function needs to be called after texture state validation in case 67 * we're generating a fragment program from fixed-function texture state. 68 * 69 * \return bitfield which will indicate _NEW_PROGRAM state if a new vertex 70 * or fragment program is being used. 71 */ 72 static GLbitfield 73 update_program(struct gl_context *ctx) 74 { 75 struct gl_program *vsProg = 76 ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX]; 77 struct gl_program *tcsProg = 78 ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_CTRL]; 79 struct gl_program *tesProg = 80 ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_EVAL]; 81 struct gl_program *gsProg = 82 ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]; 83 struct gl_program *fsProg = 84 ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT]; 85 struct gl_program *csProg = 86 ctx->_Shader->CurrentProgram[MESA_SHADER_COMPUTE]; 87 const struct gl_program *prevVP = ctx->VertexProgram._Current; 88 const struct gl_program *prevFP = ctx->FragmentProgram._Current; 89 const struct gl_program *prevGP = ctx->GeometryProgram._Current; 90 const struct gl_program *prevTCP = ctx->TessCtrlProgram._Current; 91 const struct gl_program *prevTEP = ctx->TessEvalProgram._Current; 92 const struct gl_program *prevCP = ctx->ComputeProgram._Current; 93 94 /* 95 * Set the ctx->VertexProgram._Current and ctx->FragmentProgram._Current 96 * pointers to the programs that should be used for rendering. If either 97 * is NULL, use fixed-function code paths. 98 * 99 * These programs may come from several sources. The priority is as 100 * follows: 101 * 1. OpenGL 2.0/ARB vertex/fragment shaders 102 * 2. ARB/NV vertex/fragment programs 103 * 3. ATI fragment shader 104 * 4. Programs derived from fixed-function state. 105 * 106 * Note: it's possible for a vertex shader to get used with a fragment 107 * program (and vice versa) here, but in practice that shouldn't ever 108 * come up, or matter. 109 */ 110 111 if (fsProg) { 112 /* Use GLSL fragment shader */ 113 _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, fsProg); 114 _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram, 115 NULL); 116 } 117 else if (_mesa_arb_fragment_program_enabled(ctx)) { 118 /* Use user-defined fragment program */ 119 _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, 120 ctx->FragmentProgram.Current); 121 _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram, 122 NULL); 123 } 124 else if (_mesa_ati_fragment_shader_enabled(ctx) && 125 ctx->ATIFragmentShader.Current->Program) { 126 /* Use the enabled ATI fragment shader's associated program */ 127 _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, 128 ctx->ATIFragmentShader.Current->Program); 129 _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram, 130 NULL); 131 } 132 else if (ctx->FragmentProgram._MaintainTexEnvProgram) { 133 /* Use fragment program generated from fixed-function state */ 134 struct gl_shader_program *f = _mesa_get_fixed_func_fragment_program(ctx); 135 136 _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, 137 f->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program); 138 _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram, 139 f->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program); 140 } 141 else { 142 /* No fragment program */ 143 _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, NULL); 144 _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram, 145 NULL); 146 } 147 148 if (gsProg) { 149 /* Use GLSL geometry shader */ 150 _mesa_reference_program(ctx, &ctx->GeometryProgram._Current, gsProg); 151 } else { 152 /* No geometry program */ 153 _mesa_reference_program(ctx, &ctx->GeometryProgram._Current, NULL); 154 } 155 156 if (tesProg) { 157 /* Use GLSL tessellation evaluation shader */ 158 _mesa_reference_program(ctx, &ctx->TessEvalProgram._Current, tesProg); 159 } 160 else { 161 /* No tessellation evaluation program */ 162 _mesa_reference_program(ctx, &ctx->TessEvalProgram._Current, NULL); 163 } 164 165 if (tcsProg) { 166 /* Use GLSL tessellation control shader */ 167 _mesa_reference_program(ctx, &ctx->TessCtrlProgram._Current, tcsProg); 168 } 169 else { 170 /* No tessellation control program */ 171 _mesa_reference_program(ctx, &ctx->TessCtrlProgram._Current, NULL); 172 } 173 174 /* Examine vertex program after fragment program as 175 * _mesa_get_fixed_func_vertex_program() needs to know active 176 * fragprog inputs. 177 */ 178 if (vsProg) { 179 /* Use GLSL vertex shader */ 180 _mesa_reference_program(ctx, &ctx->VertexProgram._Current, vsProg); 181 } 182 else if (_mesa_arb_vertex_program_enabled(ctx)) { 183 /* Use user-defined vertex program */ 184 _mesa_reference_program(ctx, &ctx->VertexProgram._Current, 185 ctx->VertexProgram.Current); 186 } 187 else if (ctx->VertexProgram._MaintainTnlProgram) { 188 /* Use vertex program generated from fixed-function state */ 189 _mesa_reference_program(ctx, &ctx->VertexProgram._Current, 190 _mesa_get_fixed_func_vertex_program(ctx)); 191 _mesa_reference_program(ctx, &ctx->VertexProgram._TnlProgram, 192 ctx->VertexProgram._Current); 193 } 194 else { 195 /* no vertex program */ 196 _mesa_reference_program(ctx, &ctx->VertexProgram._Current, NULL); 197 } 198 199 if (csProg) { 200 /* Use GLSL compute shader */ 201 _mesa_reference_program(ctx, &ctx->ComputeProgram._Current, csProg); 202 } else { 203 /* no compute program */ 204 _mesa_reference_program(ctx, &ctx->ComputeProgram._Current, NULL); 205 } 206 207 /* Let the driver know what's happening: 208 */ 209 if (ctx->FragmentProgram._Current != prevFP || 210 ctx->VertexProgram._Current != prevVP || 211 ctx->GeometryProgram._Current != prevGP || 212 ctx->TessEvalProgram._Current != prevTEP || 213 ctx->TessCtrlProgram._Current != prevTCP || 214 ctx->ComputeProgram._Current != prevCP) 215 return _NEW_PROGRAM; 216 217 return 0; 218 } 219 220 221 /** 222 * Examine shader constants and return either _NEW_PROGRAM_CONSTANTS or 0. 223 */ 224 static GLbitfield 225 update_program_constants(struct gl_context *ctx) 226 { 227 GLbitfield new_state = 0x0; 228 229 if (ctx->FragmentProgram._Current) { 230 const struct gl_program_parameter_list *params = 231 ctx->FragmentProgram._Current->Parameters; 232 if (params && params->StateFlags & ctx->NewState) { 233 if (ctx->DriverFlags.NewShaderConstants[MESA_SHADER_FRAGMENT]) { 234 ctx->NewDriverState |= 235 ctx->DriverFlags.NewShaderConstants[MESA_SHADER_FRAGMENT]; 236 } else { 237 new_state |= _NEW_PROGRAM_CONSTANTS; 238 } 239 } 240 } 241 242 /* Don't handle tessellation and geometry shaders here. They don't use 243 * any state constants. 244 */ 245 246 if (ctx->VertexProgram._Current) { 247 const struct gl_program_parameter_list *params = 248 ctx->VertexProgram._Current->Parameters; 249 if (params && params->StateFlags & ctx->NewState) { 250 if (ctx->DriverFlags.NewShaderConstants[MESA_SHADER_VERTEX]) { 251 ctx->NewDriverState |= 252 ctx->DriverFlags.NewShaderConstants[MESA_SHADER_VERTEX]; 253 } else { 254 new_state |= _NEW_PROGRAM_CONSTANTS; 255 } 256 } 257 } 258 259 return new_state; 260 } 261 262 263 /** 264 * Compute derived GL state. 265 * If __struct gl_contextRec::NewState is non-zero then this function \b must 266 * be called before rendering anything. 267 * 268 * Calls dd_function_table::UpdateState to perform any internal state 269 * management necessary. 270 * 271 * \sa _mesa_update_modelview_project(), _mesa_update_texture(), 272 * _mesa_update_buffer_bounds(), 273 * _mesa_update_lighting() and _mesa_update_tnl_spaces(). 274 */ 275 void 276 _mesa_update_state_locked( struct gl_context *ctx ) 277 { 278 GLbitfield new_state = ctx->NewState; 279 GLbitfield new_prog_state = 0x0; 280 const GLbitfield computed_states = ~(_NEW_CURRENT_ATTRIB | _NEW_LINE); 281 282 /* we can skip a bunch of state validation checks if the dirty 283 * state matches one or more bits in 'computed_states'. 284 */ 285 if ((new_state & computed_states) == 0) 286 goto out; 287 288 if (MESA_VERBOSE & VERBOSE_STATE) 289 _mesa_print_state("_mesa_update_state", new_state); 290 291 if (new_state & _NEW_BUFFERS) 292 _mesa_update_framebuffer(ctx, ctx->ReadBuffer, ctx->DrawBuffer); 293 294 /* Handle Core and Compatibility contexts separately. */ 295 if (ctx->API == API_OPENGL_COMPAT || 296 ctx->API == API_OPENGLES) { 297 GLbitfield prog_flags = _NEW_PROGRAM; 298 299 /* Determine which state flags effect vertex/fragment program state */ 300 if (ctx->FragmentProgram._MaintainTexEnvProgram) { 301 prog_flags |= (_NEW_BUFFERS | _NEW_TEXTURE_OBJECT | _NEW_FOG | 302 _NEW_VARYING_VP_INPUTS | _NEW_LIGHT | _NEW_POINT | 303 _NEW_RENDERMODE | _NEW_PROGRAM | _NEW_FRAG_CLAMP | 304 _NEW_COLOR | _NEW_TEXTURE_STATE); 305 } 306 if (ctx->VertexProgram._MaintainTnlProgram) { 307 prog_flags |= (_NEW_VARYING_VP_INPUTS | _NEW_TEXTURE_OBJECT | 308 _NEW_TEXTURE_MATRIX | _NEW_TRANSFORM | _NEW_POINT | 309 _NEW_FOG | _NEW_LIGHT | _NEW_TEXTURE_STATE | 310 _MESA_NEW_NEED_EYE_COORDS); 311 } 312 313 /* 314 * Now update derived state info 315 */ 316 if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION)) 317 _mesa_update_modelview_project( ctx, new_state ); 318 319 if (new_state & _NEW_TEXTURE_MATRIX) 320 _mesa_update_texture_matrices(ctx); 321 322 if (new_state & (_NEW_TEXTURE_OBJECT | _NEW_TEXTURE_STATE | _NEW_PROGRAM)) 323 _mesa_update_texture_state(ctx); 324 325 if (new_state & _NEW_LIGHT) 326 _mesa_update_lighting(ctx); 327 328 if (new_state & _NEW_PIXEL) 329 _mesa_update_pixel( ctx ); 330 331 /* ctx->_NeedEyeCoords is now up to date. 332 * 333 * If the truth value of this variable has changed, update for the 334 * new lighting space and recompute the positions of lights and the 335 * normal transform. 336 * 337 * If the lighting space hasn't changed, may still need to recompute 338 * light positions & normal transforms for other reasons. 339 */ 340 if (new_state & _MESA_NEW_NEED_EYE_COORDS) 341 _mesa_update_tnl_spaces( ctx, new_state ); 342 343 if (new_state & prog_flags) { 344 /* When we generate programs from fixed-function vertex/fragment state 345 * this call may generate/bind a new program. If so, we need to 346 * propogate the _NEW_PROGRAM flag to the driver. 347 */ 348 new_prog_state |= update_program(ctx); 349 } 350 } else { 351 /* GL Core and GLES 2/3 contexts */ 352 if (new_state & (_NEW_TEXTURE_OBJECT | _NEW_PROGRAM)) 353 _mesa_update_texture_state(ctx); 354 355 if (new_state & _NEW_PROGRAM) 356 update_program(ctx); 357 } 358 359 if (new_state & _NEW_ARRAY) 360 _mesa_update_vao_client_arrays(ctx, ctx->Array.VAO); 361 362 out: 363 new_prog_state |= update_program_constants(ctx); 364 365 ctx->NewState |= new_prog_state; 366 vbo_exec_invalidate_state(ctx); 367 368 /* 369 * Give the driver a chance to act upon the new_state flags. 370 * The driver might plug in different span functions, for example. 371 * Also, this is where the driver can invalidate the state of any 372 * active modules (such as swrast_setup, swrast, tnl, etc). 373 */ 374 ctx->Driver.UpdateState(ctx); 375 ctx->NewState = 0; 376 ctx->Array.VAO->NewArrays = 0x0; 377 } 378 379 380 /* This is the usual entrypoint for state updates: 381 */ 382 void 383 _mesa_update_state( struct gl_context *ctx ) 384 { 385 _mesa_lock_context_textures(ctx); 386 _mesa_update_state_locked(ctx); 387 _mesa_unlock_context_textures(ctx); 388 } 389 390 391 392 393 /** 394 * Want to figure out which fragment program inputs are actually 395 * constant/current values from ctx->Current. These should be 396 * referenced as a tracked state variable rather than a fragment 397 * program input, to save the overhead of putting a constant value in 398 * every submitted vertex, transferring it to hardware, interpolating 399 * it across the triangle, etc... 400 * 401 * When there is a VP bound, just use vp->outputs. But when we're 402 * generating vp from fixed function state, basically want to 403 * calculate: 404 * 405 * vp_out_2_fp_in( vp_in_2_vp_out( varying_inputs ) | 406 * potential_vp_outputs ) 407 * 408 * Where potential_vp_outputs is calculated by looking at enabled 409 * texgen, etc. 410 * 411 * The generated fragment program should then only declare inputs that 412 * may vary or otherwise differ from the ctx->Current values. 413 * Otherwise, the fp should track them as state values instead. 414 */ 415 void 416 _mesa_set_varying_vp_inputs( struct gl_context *ctx, 417 GLbitfield varying_inputs ) 418 { 419 if (ctx->API != API_OPENGL_COMPAT && 420 ctx->API != API_OPENGLES) 421 return; 422 423 if (ctx->varying_vp_inputs != varying_inputs) { 424 ctx->varying_vp_inputs = varying_inputs; 425 426 /* Only the fixed-func generated programs need to use the flag 427 * and the fixed-func fragment program uses it only if there is also 428 * a fixed-func vertex program, so this only depends on the latter. 429 * 430 * It's okay to check the VP pointer here, because this is called after 431 * _mesa_update_state in the vbo module. */ 432 if (ctx->VertexProgram._TnlProgram || 433 ctx->FragmentProgram._TexEnvProgram) { 434 ctx->NewState |= _NEW_VARYING_VP_INPUTS; 435 } 436 /*printf("%s %x\n", __func__, varying_inputs);*/ 437 } 438 } 439 440 441 /** 442 * Used by drivers to tell core Mesa that the driver is going to 443 * install/ use its own vertex program. In particular, this will 444 * prevent generated fragment programs from using state vars instead 445 * of ordinary varyings/inputs. 446 */ 447 void 448 _mesa_set_vp_override(struct gl_context *ctx, GLboolean flag) 449 { 450 if (ctx->VertexProgram._Overriden != flag) { 451 ctx->VertexProgram._Overriden = flag; 452 453 /* Set one of the bits which will trigger fragment program 454 * regeneration: 455 */ 456 ctx->NewState |= _NEW_PROGRAM; 457 } 458 } 459
