From 23caf20169ac38436ee9c13914f1d6aa7cf6bb5e Mon Sep 17 00:00:00 2001 From: Keith Whitwell Date: Thu, 16 Nov 2000 21:05:34 +0000 Subject: Move the transform and lighting code to two new directories math: Provides basic matrix and vector functionality that might be useful to multiple software t&l implementations, and is used by core mesa to manage the Model, Project, etc matrices. tnl: The real transform & lighting code from core mesa, including everything from glVertex3f through vertex buffer handling, transformation, clipping, lighting and handoff to a driver for rasterization. The interfaces of these can be further tightened up, but the basic splitting up of state and code move is done. --- src/mesa/tnl/t_pipeline.c | 496 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 496 insertions(+) create mode 100644 src/mesa/tnl/t_pipeline.c (limited to 'src/mesa/tnl/t_pipeline.c') diff --git a/src/mesa/tnl/t_pipeline.c b/src/mesa/tnl/t_pipeline.c new file mode 100644 index 0000000000..03c93911b9 --- /dev/null +++ b/src/mesa/tnl/t_pipeline.c @@ -0,0 +1,496 @@ +/* $Id: t_pipeline.c,v 1.1 2000/11/16 21:05:42 keithw Exp $ */ + +/* + * Mesa 3-D graphics library + * Version: 3.5 + * + * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* Dynamic pipelines, support for CVA. + * Copyright (C) 1999 Keith Whitwell. + */ + +#include "glheader.h" +#include "context.h" +#include "mem.h" +#include "mmath.h" +#include "state.h" +#include "types.h" + +#include "math/m_translate.h" +#include "math/m_xform.h" + +#include "t_bbox.h" +#include "t_clip.h" +#include "t_cva.h" +#include "t_fog.h" +#include "t_light.h" +#include "t_pipeline.h" +#include "t_shade.h" +#include "t_stages.h" +#include "t_vbcull.h" +#include "t_vbindirect.h" +#include "t_vbrender.h" +#include "t_vbxform.h" + + + + + +void gl_print_pipe_ops( const char *msg, GLuint flags ) +{ + fprintf(stderr, + "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s\n", + msg, + flags, + (flags & PIPE_OP_CVA_PREPARE) ? "cva-prepare, " : "", + (flags & PIPE_OP_VERT_XFORM) ? "vert-xform, " : "", + (flags & PIPE_OP_NORM_XFORM) ? "norm-xform, " : "", + (flags & PIPE_OP_LIGHT) ? "light, " : "", + (flags & PIPE_OP_FOG) ? "fog, " : "", + (flags & PIPE_OP_TEX0) ? "tex-0, " : "", + (flags & PIPE_OP_TEX1) ? "tex-1, " : "", + (flags & PIPE_OP_RAST_SETUP_0) ? "rast-0, " : "", + (flags & PIPE_OP_RAST_SETUP_1) ? "rast-1, " : "", + (flags & PIPE_OP_RENDER) ? "render, " : ""); + +} + + + +/* Have to reset only those parts of the vb which are being recalculated. + */ +void gl_reset_cva_vb( struct vertex_buffer *VB, GLuint stages ) +{ + GLcontext *ctx = VB->ctx; + TNLcontext *tnl = TNL_CONTEXT(ctx); + + if (MESA_VERBOSE&VERBOSE_PIPELINE) + gl_print_pipe_ops( "reset cva vb", stages ); + + if (stages & PIPE_OP_VERT_XFORM) + { + if (VB->ClipOrMask & CLIP_USER_BIT) + MEMSET(VB->UserClipMask, 0, VB->Count); + + VB->ClipOrMask = 0; + VB->ClipAndMask = CLIP_ALL_BITS; + VB->CullMode = 0; + VB->CullFlag[0] = VB->CullFlag[1] = 0; + VB->Culled = 0; + } + + if (stages & PIPE_OP_NORM_XFORM) { + VB->NormalPtr = &tnl->CVA.v.Normal; + } + + if (stages & PIPE_OP_LIGHT) + { + VB->ColorPtr = VB->Color[0] = VB->Color[1] = &tnl->CVA.v.Color; + VB->IndexPtr = VB->Index[0] = VB->Index[1] = &tnl->CVA.v.Index; + } + else if (stages & PIPE_OP_FOG) + { + if (ctx->Light.Enabled) { + VB->Color[0] = VB->LitColor[0]; + VB->Color[1] = VB->LitColor[1]; + VB->Index[0] = VB->LitIndex[0]; + VB->Index[1] = VB->LitIndex[1]; + } else { + VB->Color[0] = VB->Color[1] = &tnl->CVA.v.Color; + VB->Index[0] = VB->Index[1] = &tnl->CVA.v.Index; + } + VB->ColorPtr = VB->Color[0]; + VB->IndexPtr = VB->Index[0]; + } +} + + + + + + +static void pipeline_ctr( struct gl_pipeline *p, GLcontext *ctx, GLuint type ) +{ + GLuint i; + (void) ctx; + + p->state_change = 0; + p->cva_state_change = 0; + p->inputs = 0; + p->outputs = 0; + p->type = type; + p->ops = 0; + + for (i = 0 ; i < gl_default_nr_stages ; i++) + p->state_change |= gl_default_pipeline[i].state_change; +} + + +void _tnl_pipeline_init( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + + MEMCPY( tnl->PipelineStage, + gl_default_pipeline, + sizeof(*gl_default_pipeline) * gl_default_nr_stages ); + + tnl->NrPipelineStages = gl_default_nr_stages; + + pipeline_ctr( &tnl->CVA.elt, ctx, PIPE_IMMEDIATE); + pipeline_ctr( &tnl->CVA.pre, ctx, PIPE_PRECALC ); +} + + + +#define MINIMAL_VERT_DATA (VERT_DATA & ~(VERT_TEX0_4 | \ + VERT_TEX1_4 | \ + VERT_TEX2_4 | \ + VERT_TEX3_4 | \ + VERT_EVAL_ANY)) + +#define VERT_CURRENT_DATA (VERT_TEX0_1234 | \ + VERT_TEX1_1234 | \ + VERT_TEX2_1234 | \ + VERT_TEX3_1234 | \ + VERT_RGBA | \ + VERT_SPEC_RGB | \ + VERT_FOG_COORD | \ + VERT_INDEX | \ + VERT_EDGE | \ + VERT_NORM | \ + VERT_MATERIAL) + +/* Called prior to every recomputation of the CVA precalc data, except where + * the driver is able to calculate the pipeline unassisted. + */ +static void build_full_precalc_pipeline( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct gl_pipeline_stage *pipeline = tnl->PipelineStage; + struct gl_cva *cva = &tnl->CVA; + struct gl_pipeline *pre = &cva->pre; + struct gl_pipeline_stage **stages = pre->stages; + GLuint i; + GLuint newstate = pre->new_state; + GLuint changed_ops = 0; + GLuint oldoutputs = pre->outputs; + GLuint oldinputs = pre->inputs; + GLuint fallback = (VERT_CURRENT_DATA & tnl->_CurrentFlag & + ~tnl->_ArraySummary); + GLuint changed_outputs = (tnl->_ArrayNewState | + (fallback & cva->orflag)); + GLuint available = fallback | tnl->_ArrayFlags; + + pre->cva_state_change = 0; + pre->ops = 0; + pre->outputs = 0; + pre->inputs = 0; + pre->forbidden_inputs = 0; + pre->fallback = 0; + + /* KW: Disable data reuse during Mesa reorg. Make this more readable... + */ + newstate = ~0; + + if (tnl->_ArraySummary & VERT_ELT) + cva->orflag &= VERT_MATERIAL; + + cva->orflag &= ~(tnl->_ArraySummary & ~VERT_OBJ_ANY); + available &= ~cva->orflag; + + pre->outputs = available; + pre->inputs = available; + + if (MESA_VERBOSE & VERBOSE_PIPELINE) { + fprintf(stderr, ": Rebuild pipeline\n"); + gl_print_vert_flags("orflag", cva->orflag); + } + + + + /* If something changes in the pipeline, tag all subsequent stages + * using this value for recalcuation. Also used to build the full + * pipeline by setting newstate and newinputs to ~0. + * + * Because all intermediate values are buffered, the new inputs + * are enough to fully specify what needs to be calculated, and a + * single pass identifies all stages requiring recalculation. + */ + for (i = 0 ; i < tnl->NrPipelineStages ; i++) + { + pipeline[i].check(ctx, &pipeline[i]); + + if (pipeline[i].type & PIPE_PRECALC) + { + if ((newstate & pipeline[i].cva_state_change) || + (changed_outputs & pipeline[i].inputs) || + !pipeline[i].inputs) + { + changed_ops |= pipeline[i].ops; + changed_outputs |= pipeline[i].outputs; + pipeline[i].active &= ~PIPE_PRECALC; + + if ((pipeline[i].inputs & ~available) == 0 && + (pipeline[i].ops & pre->ops) == 0) + { + pipeline[i].active |= PIPE_PRECALC; + *stages++ = &pipeline[i]; + } + } + + /* Incompatible with multiple stages structs implementing + * the same stage. + */ + available &= ~pipeline[i].outputs; + pre->outputs &= ~pipeline[i].outputs; + + if (pipeline[i].active & PIPE_PRECALC) { + pre->ops |= pipeline[i].ops; + pre->outputs |= pipeline[i].outputs; + available |= pipeline[i].outputs; + pre->forbidden_inputs |= pipeline[i].pre_forbidden_inputs; + } + } + else if (pipeline[i].active & PIPE_PRECALC) + { + pipeline[i].active &= ~PIPE_PRECALC; + changed_outputs |= pipeline[i].outputs; + changed_ops |= pipeline[i].ops; + } + } + + *stages = 0; + + pre->new_outputs = pre->outputs & (changed_outputs | ~oldoutputs); + pre->new_inputs = pre->inputs & ~oldinputs; + pre->fallback = pre->inputs & fallback; + pre->forbidden_inputs |= pre->inputs & fallback; + + pre->changed_ops = changed_ops; +} + +void gl_build_precalc_pipeline( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct gl_pipeline *pre = &tnl->CVA.pre; + struct gl_pipeline *elt = &tnl->CVA.elt; + + if (!ctx->Driver.BuildPrecalcPipeline || + !ctx->Driver.BuildPrecalcPipeline( ctx )) + build_full_precalc_pipeline( ctx ); + + pre->data_valid = 0; + pre->pipeline_valid = 1; + elt->pipeline_valid = 0; + + tnl->CVA.orflag = 0; + + if (MESA_VERBOSE&VERBOSE_PIPELINE) + gl_print_pipeline( ctx, pre ); +} + + +static void build_full_immediate_pipeline( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct gl_pipeline_stage *pipeline = tnl->PipelineStage; + struct gl_cva *cva = &tnl->CVA; + struct gl_pipeline *pre = &cva->pre; + struct gl_pipeline *elt = &cva->elt; + struct gl_pipeline_stage **stages = elt->stages; + GLuint i; + GLuint newstate = elt->new_state; + GLuint active_ops = 0; + GLuint available = cva->orflag | MINIMAL_VERT_DATA; + GLuint generated = 0; + GLuint is_elt = 0; + + if (pre->data_valid && tnl->CompileCVAFlag) { + is_elt = 1; + active_ops = cva->pre.ops; + available |= pre->outputs | VERT_PRECALC_DATA; + } + + + elt->outputs = 0; /* not used */ + elt->inputs = 0; + + for (i = 0 ; i < tnl->NrPipelineStages ; i++) { + pipeline[i].active &= ~PIPE_IMMEDIATE; + + if ((pipeline[i].state_change & newstate) || + (pipeline[i].elt_forbidden_inputs & available)) + { + pipeline[i].check(ctx, &pipeline[i]); + } + + if ((pipeline[i].type & PIPE_IMMEDIATE) && + (pipeline[i].ops & active_ops) == 0 && + (pipeline[i].elt_forbidden_inputs & available) == 0 + ) + { + if (pipeline[i].inputs & ~available) + elt->forbidden_inputs |= pipeline[i].inputs & ~available; + else + { + elt->inputs |= pipeline[i].inputs & ~generated; + elt->forbidden_inputs |= pipeline[i].elt_forbidden_inputs; + pipeline[i].active |= PIPE_IMMEDIATE; + *stages++ = &pipeline[i]; + generated |= pipeline[i].outputs; + available |= pipeline[i].outputs; + active_ops |= pipeline[i].ops; + } + } + } + + *stages = 0; + + elt->copy_transformed_data = 1; + elt->replay_copied_vertices = 0; + + if (is_elt) { + cva->merge = elt->inputs & pre->outputs; + elt->ops = active_ops & ~pre->ops; + } +} + + + +void gl_build_immediate_pipeline( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct gl_pipeline *elt = &tnl->CVA.elt; + + if (!ctx->Driver.BuildEltPipeline || + !ctx->Driver.BuildEltPipeline( ctx )) { + build_full_immediate_pipeline( ctx ); + } + + elt->pipeline_valid = 1; + tnl->CVA.orflag = 0; + + if (MESA_VERBOSE&VERBOSE_PIPELINE) + gl_print_pipeline( ctx, elt ); +} + +#define INTERESTED ~0 + +void gl_update_pipelines( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint newstate = ctx->NewState; + struct gl_cva *cva = &tnl->CVA; + + newstate &= INTERESTED; + + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_STATE)) + gl_print_enable_flags("enabled", ctx->_Enabled); + + if (newstate || + cva->lock_changed || + cva->orflag != cva->last_orflag || + tnl->_ArrayFlags != cva->last_array_flags) + { + GLuint flags = VERT_WIN; + + if (ctx->Visual.RGBAflag) { + flags |= VERT_RGBA; + if (ctx->_TriangleCaps && DD_SEPERATE_SPECULAR) + flags |= VERT_SPEC_RGB; + } else + flags |= VERT_INDEX; + + if (ctx->Texture._ReallyEnabled & TEXTURE0_ANY) + flags |= VERT_TEX0_ANY; + + if (ctx->Texture._ReallyEnabled & TEXTURE1_ANY) + flags |= VERT_TEX1_ANY; + +#if MAX_TEXTURE_UNITS > 2 + if (ctx->Texture._ReallyEnabled & TEXTURE2_ANY) + flags |= VERT_TEX2_ANY; +#endif +#if MAX_TEXTURE_UNITS > 3 + if (ctx->Texture._ReallyEnabled & TEXTURE3_ANY) + flags |= VERT_TEX3_ANY; +#endif + + if (ctx->Polygon._Unfilled) + flags |= VERT_EDGE; + + if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT) + flags |= VERT_FOG_COORD; + + if (ctx->RenderMode==GL_FEEDBACK) { + flags = (VERT_WIN | VERT_RGBA | VERT_INDEX | VERT_NORM | VERT_EDGE + | VERT_TEX0_ANY + | VERT_TEX1_ANY +#if MAX_TEXTURE_UNITS > 2 + | VERT_TEX2_ANY +#endif +#if MAX_TEXTURE_UNITS > 3 + | VERT_TEX3_ANY +#endif + ); + } + + tnl->_RenderFlags = flags; + + cva->elt.new_state |= newstate; + cva->elt.pipeline_valid = 0; + + cva->pre.new_state |= newstate; + cva->pre.forbidden_inputs = 0; + cva->pre.pipeline_valid = 0; + cva->lock_changed = 0; + } + + if (tnl->_ArrayNewState != cva->last_array_new_state) + cva->pre.pipeline_valid = 0; + + cva->pre.data_valid = 0; + cva->last_array_new_state = tnl->_ArrayNewState; + cva->last_orflag = cva->orflag; + cva->last_array_flags = tnl->_ArrayFlags; +} + +void gl_run_pipeline( struct vertex_buffer *VB ) +{ + struct gl_pipeline *pipe = VB->pipeline; + struct gl_pipeline_stage **stages = pipe->stages; + unsigned short x; + + pipe->data_valid = 1; /* optimized stages might want to reset this. */ + + if (0) gl_print_pipeline( VB->ctx, pipe ); + + START_FAST_MATH(x); + + for ( VB->Culled = 0; *stages && !VB->Culled ; stages++ ) + (*stages)->run( VB ); + + END_FAST_MATH(x); + + pipe->new_state = 0; +} + -- cgit v1.2.3