#include "texobj.h"
#include "texstate.h"
#include "varray.h"
+#include "vbo/vbo_context.h"
+#include "viewport.h"
#include "blend.h"
/**
- * Update the following fields:
- * ctx->VertexProgram._Enabled
- * ctx->FragmentProgram._Enabled
- * ctx->ATIFragmentShader._Enabled
- * This needs to be done before texture state validation.
- */
-static void
-update_program_enables(struct gl_context *ctx)
-{
- /* These _Enabled flags indicate if the user-defined ARB/NV vertex/fragment
- * program is enabled AND valid. Similarly for ATI fragment shaders.
- * GLSL shaders not relevant here.
- */
- ctx->VertexProgram._Enabled = ctx->VertexProgram.Enabled
- && ctx->VertexProgram.Current->Base.Instructions;
- ctx->FragmentProgram._Enabled = ctx->FragmentProgram.Enabled
- && ctx->FragmentProgram.Current->Base.Instructions;
- ctx->ATIFragmentShader._Enabled = ctx->ATIFragmentShader.Enabled
- && ctx->ATIFragmentShader.Current->Instructions[0];
-}
-
-
-/**
- * Update the ctx->Vertex/Geometry/FragmentProgram._Current pointers to point
- * to the current/active programs. Then call ctx->Driver.BindProgram() to
- * tell the driver which programs to use.
+ * Update the ctx->*Program._Current pointers to point to the
+ * current/active programs.
*
* Programs may come from 3 sources: GLSL shaders, ARB/NV_vertex/fragment
* programs or programs derived from fixed-function state.
static GLbitfield
update_program(struct gl_context *ctx)
{
- const struct gl_shader_program *vsProg =
- ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
- const struct gl_shader_program *gsProg =
- ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY];
- struct gl_shader_program *fsProg =
- ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT];
- const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current;
- const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current;
- const struct gl_geometry_program *prevGP = ctx->GeometryProgram._Current;
+ struct gl_program *vsProg =
+ ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX];
+ struct gl_program *tcsProg =
+ ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_CTRL];
+ struct gl_program *tesProg =
+ ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_EVAL];
+ struct gl_program *gsProg =
+ ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY];
+ struct gl_program *fsProg =
+ ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT];
+ struct gl_program *csProg =
+ ctx->_Shader->CurrentProgram[MESA_SHADER_COMPUTE];
+ const struct gl_program *prevVP = ctx->VertexProgram._Current;
+ const struct gl_program *prevFP = ctx->FragmentProgram._Current;
+ const struct gl_program *prevGP = ctx->GeometryProgram._Current;
+ const struct gl_program *prevTCP = ctx->TessCtrlProgram._Current;
+ const struct gl_program *prevTEP = ctx->TessEvalProgram._Current;
+ const struct gl_program *prevCP = ctx->ComputeProgram._Current;
GLbitfield new_state = 0x0;
/*
* follows:
* 1. OpenGL 2.0/ARB vertex/fragment shaders
* 2. ARB/NV vertex/fragment programs
- * 3. Programs derived from fixed-function state.
+ * 3. ATI fragment shader
+ * 4. Programs derived from fixed-function state.
*
* Note: it's possible for a vertex shader to get used with a fragment
* program (and vice versa) here, but in practice that shouldn't ever
* come up, or matter.
*/
- if (fsProg && fsProg->LinkStatus
- && fsProg->_LinkedShaders[MESA_SHADER_FRAGMENT]) {
+ if (fsProg) {
/* Use GLSL fragment shader */
- _mesa_reference_shader_program(ctx,
- &ctx->Shader._CurrentFragmentProgram,
- fsProg);
- _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
- gl_fragment_program(fsProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program));
- _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram,
- NULL);
+ _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, fsProg);
+ _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram,
+ NULL);
}
- else if (ctx->FragmentProgram._Enabled) {
+ else if (_mesa_arb_fragment_program_enabled(ctx)) {
/* Use user-defined fragment program */
- _mesa_reference_shader_program(ctx,
- &ctx->Shader._CurrentFragmentProgram,
- NULL);
- _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
- ctx->FragmentProgram.Current);
- _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram,
- NULL);
+ _mesa_reference_program(ctx, &ctx->FragmentProgram._Current,
+ ctx->FragmentProgram.Current);
+ _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram,
+ NULL);
+ }
+ else if (_mesa_ati_fragment_shader_enabled(ctx) &&
+ ctx->ATIFragmentShader.Current->Program) {
+ /* Use the enabled ATI fragment shader's associated program */
+ _mesa_reference_program(ctx, &ctx->FragmentProgram._Current,
+ ctx->ATIFragmentShader.Current->Program);
+ _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram,
+ NULL);
}
else if (ctx->FragmentProgram._MaintainTexEnvProgram) {
/* Use fragment program generated from fixed-function state */
struct gl_shader_program *f = _mesa_get_fixed_func_fragment_program(ctx);
- _mesa_reference_shader_program(ctx,
- &ctx->Shader._CurrentFragmentProgram,
- f);
- _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
- gl_fragment_program(f->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program));
- _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram,
- gl_fragment_program(f->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program));
+ _mesa_reference_program(ctx, &ctx->FragmentProgram._Current,
+ f->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program);
+ _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram,
+ f->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program);
}
else {
/* No fragment program */
- _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
- _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram,
- NULL);
+ _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, NULL);
+ _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram,
+ NULL);
}
- if (gsProg && gsProg->LinkStatus
- && gsProg->_LinkedShaders[MESA_SHADER_GEOMETRY]) {
+ if (gsProg) {
/* Use GLSL geometry shader */
- _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current,
- gl_geometry_program(gsProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program));
+ _mesa_reference_program(ctx, &ctx->GeometryProgram._Current, gsProg);
} else {
/* No geometry program */
- _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current, NULL);
+ _mesa_reference_program(ctx, &ctx->GeometryProgram._Current, NULL);
+ }
+
+ if (tesProg) {
+ /* Use GLSL tessellation evaluation shader */
+ _mesa_reference_program(ctx, &ctx->TessEvalProgram._Current, tesProg);
+ }
+ else {
+ /* No tessellation evaluation program */
+ _mesa_reference_program(ctx, &ctx->TessEvalProgram._Current, NULL);
+ }
+
+ if (tcsProg) {
+ /* Use GLSL tessellation control shader */
+ _mesa_reference_program(ctx, &ctx->TessCtrlProgram._Current, tcsProg);
+ }
+ else {
+ /* No tessellation control program */
+ _mesa_reference_program(ctx, &ctx->TessCtrlProgram._Current, NULL);
}
/* Examine vertex program after fragment program as
* _mesa_get_fixed_func_vertex_program() needs to know active
* fragprog inputs.
*/
- if (vsProg && vsProg->LinkStatus
- && vsProg->_LinkedShaders[MESA_SHADER_VERTEX]) {
+ if (vsProg) {
/* Use GLSL vertex shader */
- _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,
- gl_vertex_program(vsProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program));
+ _mesa_reference_program(ctx, &ctx->VertexProgram._Current, vsProg);
}
- else if (ctx->VertexProgram._Enabled) {
+ else if (_mesa_arb_vertex_program_enabled(ctx)) {
/* Use user-defined vertex program */
- _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,
- ctx->VertexProgram.Current);
+ _mesa_reference_program(ctx, &ctx->VertexProgram._Current,
+ ctx->VertexProgram.Current);
}
else if (ctx->VertexProgram._MaintainTnlProgram) {
/* Use vertex program generated from fixed-function state */
- _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,
- _mesa_get_fixed_func_vertex_program(ctx));
- _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram,
- ctx->VertexProgram._Current);
+ _mesa_reference_program(ctx, &ctx->VertexProgram._Current,
+ _mesa_get_fixed_func_vertex_program(ctx));
+ _mesa_reference_program(ctx, &ctx->VertexProgram._TnlProgram,
+ ctx->VertexProgram._Current);
}
else {
/* no vertex program */
- _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
- }
-
- /* Let the driver know what's happening:
- */
- if (ctx->FragmentProgram._Current != prevFP) {
- new_state |= _NEW_PROGRAM;
- if (ctx->Driver.BindProgram) {
- ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB,
- (struct gl_program *) ctx->FragmentProgram._Current);
- }
+ _mesa_reference_program(ctx, &ctx->VertexProgram._Current, NULL);
}
- if (ctx->GeometryProgram._Current != prevGP) {
- new_state |= _NEW_PROGRAM;
- if (ctx->Driver.BindProgram) {
- ctx->Driver.BindProgram(ctx, MESA_GEOMETRY_PROGRAM,
- (struct gl_program *) ctx->GeometryProgram._Current);
- }
+ if (csProg) {
+ /* Use GLSL compute shader */
+ _mesa_reference_program(ctx, &ctx->ComputeProgram._Current, csProg);
+ } else {
+ /* no compute program */
+ _mesa_reference_program(ctx, &ctx->ComputeProgram._Current, NULL);
}
- if (ctx->VertexProgram._Current != prevVP) {
+ /* Let the driver know what's happening:
+ */
+ if (ctx->FragmentProgram._Current != prevFP ||
+ ctx->VertexProgram._Current != prevVP ||
+ ctx->GeometryProgram._Current != prevGP ||
+ ctx->TessEvalProgram._Current != prevTEP ||
+ ctx->TessCtrlProgram._Current != prevTCP ||
+ ctx->ComputeProgram._Current != prevCP)
new_state |= _NEW_PROGRAM;
- if (ctx->Driver.BindProgram) {
- ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB,
- (struct gl_program *) ctx->VertexProgram._Current);
- }
- }
return new_state;
}
if (ctx->FragmentProgram._Current) {
const struct gl_program_parameter_list *params =
- ctx->FragmentProgram._Current->Base.Parameters;
+ ctx->FragmentProgram._Current->Parameters;
if (params && params->StateFlags & ctx->NewState) {
new_state |= _NEW_PROGRAM_CONSTANTS;
}
}
- if (ctx->GeometryProgram._Current) {
- const struct gl_program_parameter_list *params =
- ctx->GeometryProgram._Current->Base.Parameters;
- /*FIXME: StateFlags is always 0 because we have unnamed constant
- * not state changes */
- if (params /*&& params->StateFlags & ctx->NewState*/) {
- new_state |= _NEW_PROGRAM_CONSTANTS;
- }
- }
+ /* Don't handle tessellation and geometry shaders here. They don't use
+ * any state constants.
+ */
if (ctx->VertexProgram._Current) {
const struct gl_program_parameter_list *params =
- ctx->VertexProgram._Current->Base.Parameters;
+ ctx->VertexProgram._Current->Parameters;
if (params && params->StateFlags & ctx->NewState) {
new_state |= _NEW_PROGRAM_CONSTANTS;
}
}
-
-
-static void
-update_viewport_matrix(struct gl_context *ctx)
-{
- const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF;
- unsigned i;
-
- ASSERT(depthMax > 0);
-
- /* Compute scale and bias values. This is really driver-specific
- * and should be maintained elsewhere if at all.
- * NOTE: RasterPos uses this.
- */
- for (i = 0; i < ctx->Const.MaxViewports; i++) {
- _math_matrix_viewport(&ctx->ViewportArray[i]._WindowMap,
- ctx->ViewportArray[i].X, ctx->ViewportArray[i].Y,
- ctx->ViewportArray[i].Width, ctx->ViewportArray[i].Height,
- ctx->ViewportArray[i].Near, ctx->ViewportArray[i].Far,
- depthMax);
- }
-}
-
-
-/**
- * Update derived multisample state.
- */
-static void
-update_multisample(struct gl_context *ctx)
-{
- ctx->Multisample._Enabled = GL_FALSE;
- if (ctx->Multisample.Enabled &&
- ctx->DrawBuffer &&
- ctx->DrawBuffer->Visual.sampleBuffers)
- ctx->Multisample._Enabled = GL_TRUE;
-}
-
-
-/**
- * Update the ctx->VertexProgram._TwoSideEnabled flag.
- */
-static void
-update_twoside(struct gl_context *ctx)
-{
- if (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX] ||
- ctx->VertexProgram._Enabled) {
- ctx->VertexProgram._TwoSideEnabled = ctx->VertexProgram.TwoSideEnabled;
- } else {
- ctx->VertexProgram._TwoSideEnabled = (ctx->Light.Enabled &&
- ctx->Light.Model.TwoSide);
- }
-}
-
-
/**
* Compute derived GL state.
* If __struct gl_contextRec::NewState is non-zero then this function \b must
GLbitfield new_state = ctx->NewState;
GLbitfield prog_flags = _NEW_PROGRAM;
GLbitfield new_prog_state = 0x0;
+ const GLbitfield computed_states = ~(_NEW_CURRENT_ATTRIB | _NEW_LINE);
- if (new_state == _NEW_CURRENT_ATTRIB)
+ /* we can skip a bunch of state validation checks if the dirty
+ * state matches one or more bits in 'computed_states'.
+ */
+ if ((new_state & computed_states) == 0)
goto out;
if (MESA_VERBOSE & VERBOSE_STATE)
/* Determine which state flags effect vertex/fragment program state */
if (ctx->FragmentProgram._MaintainTexEnvProgram) {
- prog_flags |= (_NEW_BUFFERS | _NEW_TEXTURE | _NEW_FOG |
+ prog_flags |= (_NEW_BUFFERS | _NEW_TEXTURE_OBJECT | _NEW_FOG |
_NEW_VARYING_VP_INPUTS | _NEW_LIGHT | _NEW_POINT |
_NEW_RENDERMODE | _NEW_PROGRAM | _NEW_FRAG_CLAMP |
- _NEW_COLOR);
+ _NEW_COLOR | _NEW_TEXTURE_STATE);
}
if (ctx->VertexProgram._MaintainTnlProgram) {
- prog_flags |= (_NEW_VARYING_VP_INPUTS | _NEW_TEXTURE |
+ prog_flags |= (_NEW_VARYING_VP_INPUTS | _NEW_TEXTURE_OBJECT |
_NEW_TEXTURE_MATRIX | _NEW_TRANSFORM | _NEW_POINT |
- _NEW_FOG | _NEW_LIGHT |
+ _NEW_FOG | _NEW_LIGHT | _NEW_TEXTURE_STATE |
_MESA_NEW_NEED_EYE_COORDS);
}
/*
* Now update derived state info
*/
-
- if (new_state & prog_flags)
- update_program_enables( ctx );
-
if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION))
_mesa_update_modelview_project( ctx, new_state );
- if (new_state & (_NEW_PROGRAM|_NEW_TEXTURE|_NEW_TEXTURE_MATRIX))
- _mesa_update_texture( ctx, new_state );
+ if (new_state & _NEW_TEXTURE_MATRIX)
+ _mesa_update_texture_matrices(ctx);
- if (new_state & _NEW_BUFFERS)
- _mesa_update_framebuffer(ctx);
+ if (new_state & (_NEW_TEXTURE_OBJECT | _NEW_TEXTURE_STATE | _NEW_PROGRAM))
+ _mesa_update_texture_state(ctx);
- if (new_state & (_NEW_SCISSOR | _NEW_BUFFERS | _NEW_VIEWPORT))
- _mesa_update_draw_buffer_bounds( ctx );
+ if (new_state & _NEW_BUFFERS)
+ _mesa_update_framebuffer(ctx, ctx->ReadBuffer, ctx->DrawBuffer);
if (new_state & _NEW_LIGHT)
_mesa_update_lighting( ctx );
- if (new_state & (_NEW_LIGHT | _NEW_PROGRAM))
- update_twoside( ctx );
-
- if (new_state & (_NEW_STENCIL | _NEW_BUFFERS))
- _mesa_update_stencil( ctx );
-
if (new_state & _NEW_PIXEL)
- _mesa_update_pixel( ctx, new_state );
-
- if (new_state & (_NEW_BUFFERS | _NEW_VIEWPORT))
- update_viewport_matrix(ctx);
-
- if (new_state & (_NEW_MULTISAMPLE | _NEW_BUFFERS))
- update_multisample( ctx );
+ _mesa_update_pixel( ctx );
/* ctx->_NeedEyeCoords is now up to date.
*
}
if (new_state & _NEW_ARRAY)
- _mesa_update_array_object_client_arrays(ctx, ctx->Array.VAO);
-
- if (ctx->Const.CheckArrayBounds &&
- new_state & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT)) {
- _mesa_update_array_object_max_element(ctx, ctx->Array.VAO);
- }
+ _mesa_update_vao_client_arrays(ctx, ctx->Array.VAO);
out:
new_prog_state |= update_program_constants(ctx);
+ ctx->NewState |= new_prog_state;
+ vbo_exec_invalidate_state(ctx);
+
/*
* Give the driver a chance to act upon the new_state flags.
* The driver might plug in different span functions, for example.
* Also, this is where the driver can invalidate the state of any
* active modules (such as swrast_setup, swrast, tnl, etc).
- *
- * Set ctx->NewState to zero to avoid recursion if
- * Driver.UpdateState() has to call FLUSH_VERTICES(). (fixed?)
*/
- new_state = ctx->NewState | new_prog_state;
+ ctx->Driver.UpdateState(ctx);
ctx->NewState = 0;
- ctx->Driver.UpdateState(ctx, new_state);
ctx->Array.VAO->NewArrays = 0x0;
}
ctx->FragmentProgram._TexEnvProgram) {
ctx->NewState |= _NEW_VARYING_VP_INPUTS;
}
- /*printf("%s %x\n", __FUNCTION__, varying_inputs);*/
+ /*printf("%s %x\n", __func__, varying_inputs);*/
}
}