Major rework of tnl module

New array_cache module
Support 8 texture units in core mesa (now support 8 everywhere)
Rework core mesa statechange operations to avoid flushing on many
noop statechanges.

1 files changed, 273 insertions, 456 deletions

diff --git a/src/mesa/tnl/t_context.h b/src/mesa/tnl/t_context.h
index fb036b9f3d..1a4ebb2170 100644
--- a/src/mesa/tnl/t_context.h
+++ b/src/mesa/tnl/t_context.h
@@ -1,5 +1,4 @@
-
-/* $Id: t_context.h,v 1.6 2000/12/08 00:18:39 brianp Exp $ */
+/* $Id: t_context.h,v 1.7 2000/12/26 05:09:32 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -23,6 +22,9 @@
  * 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.
+ *
+ * Author:
+ *    Keith Whitwell <keithw@valinux.com>
  */
 
 #ifndef _T_CONTEXT_H
@@ -35,99 +37,91 @@
 #include "math/m_vector.h"
 #include "math/m_xform.h"
 
-#include "t_trans_elt.h"
 
+#define MAX_PIPELINE_STAGES     30
 
 
-/*
- * Bits to indicate which faces a vertex participates in,
- * what facing the primitive provoked by that vertex has,
- * and some misc. flags.
+/* Numbers for sizing immediate structs.
  */
-#define VERT_FACE_FRONT       0x1	/* is in a front-color primitive */
-#define VERT_FACE_REAR        0x2	/* is in a rear-color primitive */
-#define PRIM_FACE_FRONT       0x4	/* use front color */
-#define PRIM_FACE_REAR        0x8	/* use rear color */
-#define PRIM_CLIPPED          0x10	/* needs clipping */
-#define PRIM_USER_CLIPPED     CLIP_USER_BIT	/* 0x40 */
+#define IMM_MAX_COPIED_VERTS  3
+#define IMM_MAXDATA          (216 + IMM_MAX_COPIED_VERTS)
+#define IMM_SIZE             (IMM_MAXDATA + MAX_CLIPPED_VERTICES)
 
 
-#define PRIM_FLAG_SHIFT  2
-#define PRIM_FACE_FLAGS  (PRIM_FACE_FRONT|PRIM_FACE_REAR)
-#define VERT_FACE_FLAGS  (VERT_FACE_FRONT|VERT_FACE_REAR)
-
-#define PRIM_ANY_CLIP    (PRIM_CLIPPED|PRIM_USER_CLIPPED)
-#define PRIM_NOT_CULLED  (PRIM_ANY_CLIP|PRIM_FACE_FLAGS)
-
-/* Flags for VB->CullMode.
+/* Values for IM->BeginState 
  */
-#define CULL_MASK_ACTIVE  0x1
-#define COMPACTED_NORMALS 0x2
-#define CLIP_MASK_ACTIVE  0x4
+#define VERT_BEGIN_0    0x1	   /* glBegin (if initially inside beg/end) */
+#define VERT_BEGIN_1    0x2	   /* glBegin (if initially outside beg/end) */
+#define VERT_ERROR_0    0x4	   /* invalid_operation in initial state 0 */
+#define VERT_ERROR_1    0x8        /* invalid_operation in initial state 1 */
 
-/* Flags for selecting a shading function.  The first two bits are
- * shared with the cull mode (ie. cull_mask_active and
- * compacted_normals.)
+
+/* Flags to be added to the primitive enum in VB->Primitive.
  */
-#define SHADE_TWOSIDE           0x4
+#define PRIM_MODE_MASK  0xff    /* Extract the actual primitive */
+#define PRIM_BEGIN      0x100	/* The prim starts here (not wrapped) */
+#define PRIM_END        0x200	/* The prim ends in this VB (does not wrap) */
+#define PRIM_PARITY     0x400	/* The prim wrapped on an odd number of verts */
+#define PRIM_LAST       0x800   /* No more prims in the VB */
 
 
-/* KW: Flags that describe the current vertex state, and the contents
- * of a vertex in a vertex-cassette.
+/* Flags that describe the inputs and outputs of pipeline stages, and
+ * the contents of a vertex-cassette. 
  *
- * For really major expansion, consider a 'VERT_ADDITIONAL_FLAGS' flag,
- * which means there is data in another flags array (eg, extra_flags[]).
+ * 5 spare flags, rearrangement of eval flags can secure at least 3
+ * more. 
+ */
+#define VERT_OBJ             _NEW_ARRAY_VERTEX	
+#define VERT_RGBA            _NEW_ARRAY_COLOR	
+#define VERT_NORM            _NEW_ARRAY_NORMAL	
+#define VERT_INDEX           _NEW_ARRAY_INDEX	
+#define VERT_EDGE            _NEW_ARRAY_EDGEFLAG	
+#define VERT_SPEC_RGB        _NEW_ARRAY_SECONDARYCOLOR
+#define VERT_FOG_COORD       _NEW_ARRAY_FOGCOORD
+#define VERT_TEX0            _NEW_ARRAY_TEXCOORD_0
+#define VERT_TEX1            _NEW_ARRAY_TEXCOORD_1
+#define VERT_TEX2            _NEW_ARRAY_TEXCOORD_2
+#define VERT_TEX3            _NEW_ARRAY_TEXCOORD_3
+#define VERT_TEX4            _NEW_ARRAY_TEXCOORD_4
+#define VERT_TEX5            _NEW_ARRAY_TEXCOORD_5
+#define VERT_TEX6            _NEW_ARRAY_TEXCOORD_6
+#define VERT_TEX7            _NEW_ARRAY_TEXCOORD_7
+#define VERT_EVAL_C1         0x8000     /* imm only */
+#define VERT_EVAL_C2         0x10000    /* imm only */
+#define VERT_EVAL_P1         0x20000    /* imm only */
+#define VERT_EVAL_P2         0x40000    /* imm only */
+#define VERT_OBJ_3           0x80000    /* imm only */
+#define VERT_OBJ_4           0x100000   /* imm only */
+#define VERT_MATERIAL        0x200000   /* imm only, but tested in vb code */
+#define VERT_ELT             0x400000   /* imm only */
+#define VERT_BEGIN           0x800000   /* imm only, but tested in vb code */
+#define VERT_END             0x1000000  /* imm only, but tested in vb code */
+#define VERT_END_VB          0x2000000  /* imm only, but tested in vb code */
+#define VERT_POINT_SIZE      0x4000000  /* vb only, could reuse a bit */
+#define VERT_EYE             VERT_BEGIN /* vb only, reuse imm bit */
+#define VERT_CLIP            VERT_END   /* vb only, reuse imm bit*/
+
+
+/* Flags for IM->TexCoordSize.  Enough flags for 16 units.
  */
+#define TEX_0_SIZE_3          0x1
+#define TEX_0_SIZE_4          0x1000
+#define TEX_SIZE_3(unit)      (TEX_0_SIZE_3<<unit)
+#define TEX_SIZE_4(unit)      (TEX_0_SIZE_4<<unit)
 
-#define VERT_OBJ_2           0x1	/* glVertex2 */
-#define VERT_OBJ_3           0x2        /* glVertex3 */
-#define VERT_OBJ_4           0x4        /* glVertex4 */
-#define VERT_BEGIN           0x8	/* glBegin */
-#define VERT_END             0x10	/* glEnd */
-#define VERT_ELT             0x20	/* glArrayElement */
-#define VERT_RGBA            0x40	/* glColor */
-#define VERT_NORM            0x80	/* glNormal */
-#define VERT_INDEX           0x100	/* glIndex */
-#define VERT_EDGE            0x200	/* glEdgeFlag */
-#define VERT_MATERIAL        0x400	/* glMaterial */
-#define VERT_END_VB          0x800	/* end vb marker */
-#define VERT_TEX0            0x1000	
-#define VERT_TEX1            0x2000
-#define VERT_TEX2            0x3000
-#define VERT_TEX3            0x4000
-#define VERT_TEX4            0x10000	
-#define VERT_TEX5            0x20000
-#define VERT_TEX6            0x30000
-#define VERT_TEX7            0x40000
-#define VERT_TEX8            0x100000	
-#define VERT_TEX9            0x200000
-#define VERT_TEX10           0x300000
-#define VERT_TEX11           0x400000
-#define VERT_EVAL_C1         0x1000000  /* could reuse OBJ bits for this? */
-#define VERT_EVAL_C2         0x2000000  /*    - or just use 3 bits */
-#define VERT_EVAL_P1         0x4000000  /*  */
-#define VERT_EVAL_P2         0x8000000  /*  */
-#define VERT_SPEC_RGB        0x10000000	
-#define VERT_FOG_COORD       0x20000000	
-#define VERT_POINT_SIZE      0x40000000
-
-#define VERT_EYE             VERT_BEGIN /* reuse */
-#define VERT_WIN             VERT_END   /* reuse */
-#define VERT_SETUP_FULL      VERT_EVAL_P1 /* Rastersetup has been done */
-#define VERT_PRECALC_DATA    VERT_END_VB /* reuse */
 
 /* Shorthands.
  */
-
 #define VERT_EVAL_ANY      (VERT_EVAL_C1|VERT_EVAL_P1|	\
                             VERT_EVAL_C2|VERT_EVAL_P2)
 
-#define VERT_OBJ_23       (VERT_OBJ_3|VERT_OBJ_2)
+#define VERT_OBJ_23       (VERT_OBJ_3|VERT_OBJ)
 #define VERT_OBJ_234      (VERT_OBJ_4|VERT_OBJ_23)
-#define VERT_OBJ_ANY      VERT_OBJ_2
 
 #define VERT_TEX0_SHIFT 11
+
 #define VERT_TEX(i)        (VERT_TEX0 << i)
+
 #define VERT_TEX_ANY       (VERT_TEX0 |		\
                             VERT_TEX1 |		\
                             VERT_TEX2 |		\
@@ -135,461 +129,287 @@
                             VERT_TEX4 |		\
                             VERT_TEX5 |		\
                             VERT_TEX6 |		\
-                            VERT_TEX7 |		\
-                            VERT_TEX8 |		\
-                            VERT_TEX9 |		\
-                            VERT_TEX10 |	\
-                            VERT_TEX11)
+                            VERT_TEX7)
+
+#define VERT_FIXUP        (VERT_TEX_ANY |	\
+                           VERT_RGBA |		\
+                           VERT_SPEC_RGB |	\
+                           VERT_FOG_COORD |	\
+			   VERT_INDEX |		\
+                           VERT_EDGE |		\
+                           VERT_NORM)
 
-#define VERT_FIXUP         (VERT_TEX_ANY |	\
+#define VERT_CURRENT_DATA  (VERT_FIXUP |	\
+			    VERT_MATERIAL)
+
+#define VERT_DATA          (VERT_TEX_ANY |	\
 			    VERT_RGBA |		\
 			    VERT_SPEC_RGB |	\
 			    VERT_FOG_COORD |	\
                             VERT_INDEX |	\
                             VERT_EDGE |		\
-                            VERT_NORM)
-
-#define VERT_DATA          (VERT_TEX_ANY | \
-			    VERT_RGBA | \
-			    VERT_SPEC_RGB | \
-			    VERT_FOG_COORD | \
-                            VERT_INDEX | \
-                            VERT_EDGE | \
-                            VERT_NORM | \
-	                    VERT_OBJ_ANY | \
-                            VERT_MATERIAL | \
-                            VERT_ELT | \
-	                    VERT_EVAL_ANY | \
-                            VERT_FOG_COORD)
-
-
-
-
-struct gl_pipeline;
-struct tnl_context;
-
-/**
- ** Vertex buffer/array structures
- **/
-
-struct vertex_data
-{
-   GLfloat (*Obj)[4];
-   GLfloat (*Normal)[3];
-   GLchan  (*Color)[4];
-   GLuint   *Index;
-   GLubyte  *EdgeFlag;
-   GLfloat (*TexCoord[MAX_TEXTURE_UNITS])[4];
-   GLuint   *Elt;
-   GLfloat  *FogCoord;
-   GLubyte  (*SecondaryColor)[4];
-};
-
-struct vertex_arrays
-{
-   GLvector4f  Obj;
-   GLvector3f  Normal;
-   GLvector4ub Color;
-   GLvector1ui Index;
-   GLvector1ub EdgeFlag;
-   GLvector4f  TexCoord[MAX_TEXTURE_UNITS];
-   GLvector1ui Elt;
-   GLvector4ub SecondaryColor;
-   GLvector1f  FogCoord;
-};
+                            VERT_NORM |		\
+	                    VERT_OBJ |	\
+                            VERT_MATERIAL |	\
+                            VERT_ELT |		\
+	                    VERT_EVAL_ANY)
 
-struct vertex_array_pointers
-{
-   GLvector4f  *Obj;
-   GLvector3f  *Normal;
-   GLvector4ub *Color;
-   GLvector1ui *Index;
-   GLvector1ub *EdgeFlag;
-   GLvector4f  *TexCoord[MAX_TEXTURE_UNITS];
-   GLvector1ui *Elt;
-   GLvector4ub *SecondaryColor;
-   GLvector1f *FogCoord;
-};
-
-/* Values for VB->Type */
-enum {
-   VB_IMMEDIATE,
-   VB_CVA_PRECALC
-};
-
-
-/* Values for immediate->BeginState */
-#define VERT_BEGIN_0    0x1	   /* glBegin (if initially inside beg/end) */
-#define VERT_BEGIN_1    0x2	   /* glBegin (if initially outside beg/end) */
-#define VERT_ERROR_0    0x4	   /* invalid_operation in initial state 0 */
-#define VERT_ERROR_1    0x8        /* invalid_operation in initial state 1 */
 
 /* KW: Represents everything that can take place between a begin and
- * end, and can represent multiple begin/end pairs.  This plus *any*
- * state variable (GLcontext) should be all you need to replay the
- * represented begin/end pairs as if they took place in that state.
- *
- * Thus this is sufficient for both immediate and compiled modes, but
- * we could/should throw some elements away for compiled mode if we
- * know they were empty.
+ * end, and can represent multiple begin/end pairs.  Can be used to
+ * losslessly encode this information in display lists.
  */
 struct immediate
 {
-   struct immediate *next;	/* for cache of free IM's */
+   struct __GLcontextRec *backref;		
    GLuint id, ref_count;
 
    /* This must be saved when immediates are shared in display lists.
     */
-   GLuint Start, Count;
+   GLuint CopyStart, Start, Count;
    GLuint LastData;		/* count or count+1 */
    GLuint AndFlag, OrFlag;
-   GLuint Tex3Flag, Tex4Flag;	/* keep track of texcoord sizes */
+   GLuint TexSize;		/* keep track of texcoord sizes */
    GLuint BeginState, SavedBeginState;
    GLuint LastPrimitive;	
 
-   GLuint ArrayAndFlags;	/* precalc'ed for glArrayElt */
-   GLuint ArrayIncr;
+   GLuint ArrayEltFlags;	/* precalc'ed for glArrayElt */
+   GLuint ArrayEltIncr;
    GLuint ArrayEltFlush;
    GLuint FlushElt;
 
-   GLuint  Primitive[VB_SIZE];	/* GLubyte would do... */
-   GLuint  NextPrimitive[VB_SIZE];
+   GLuint MaxTextureUnits;	/* precalc'ed for glMultiTexCoordARB */
 
-   /* allocate storage for these on demand:
+   /* Temporary values created when vertices are copied into the 
+    * first 3 slots of the struct:
     */
-   struct  gl_material (*Material)[2];
-   GLuint  *MaterialMask;
+   GLuint CopyOrFlag;
+   GLuint CopyAndFlag;
+   GLuint CopyTexSize;
+
 
-   GLfloat (*TexCoordPtr[MAX_TEXTURE_UNITS])[4];
+   /* allocate storage for these on demand:
+    */
+   struct gl_material (*Material)[2];
+   GLuint *MaterialMask;
+   GLfloat *NormalLengths;	
+   GLfloat (*TexCoord[MAX_TEXTURE_UNITS])[4];
 
-   struct vertex_arrays v;
+   GLuint  Primitive[IMM_SIZE];	    /* BEGIN/END */
+   GLuint  PrimitiveLength[IMM_SIZE]; /* BEGIN/END */
+   GLuint  Flag[IMM_SIZE];	    /* VERT_* flags */
+   GLchan  Color[IMM_SIZE][4];	  
+   GLfloat Obj[IMM_SIZE][4];	  
+   GLfloat Normal[IMM_SIZE][3];
+   GLfloat TexCoord0[IMM_SIZE][4];  /* just VERT_TEX0 */
+   GLuint  Elt[IMM_SIZE];
+   GLubyte EdgeFlag[IMM_SIZE];
+   GLuint  Index[IMM_SIZE];
+   GLubyte SecondaryColor[IMM_SIZE][4];
+   GLfloat FogCoord[IMM_SIZE];
+};
 
-   struct __GLcontextRec *backref;		
 
-   /* Normal lengths, zero if not available.
-    */
-   GLfloat   *NormalLengths;
-   GLuint     LastCalcedLength;
-
-   GLuint  Flag[VB_SIZE];    /* bitwise-OR of VERT_ flags */
-   GLchan  Color[VB_SIZE][4];
-   GLfloat Obj[VB_SIZE][4];
-   GLfloat Normal[VB_SIZE][3];
-   GLfloat TexCoord[MAX_TEXTURE_UNITS][VB_SIZE][4];
-   GLuint  Elt[VB_SIZE];
-   GLubyte EdgeFlag[VB_SIZE];
-   GLuint  Index[VB_SIZE];
-   GLubyte SecondaryColor[VB_SIZE][4];
-   GLfloat FogCoord[VB_SIZE];
+struct vertex_arrays
+{
+   GLvector4f  Obj;
+   GLvector3f  Normal;
+   GLvector4ub Color;
+   GLvector1ui Index;
+   GLvector1ub EdgeFlag;
+   GLvector4f  TexCoord[MAX_TEXTURE_UNITS];
+   GLvector1ui Elt;
+   GLvector4ub SecondaryColor;
+   GLvector1f  FogCoord;
 };
 
 
-/* Not so big on storage these days, although still has pointers to
- * arrays used for temporary results.
+typedef struct gl_material GLmaterial;
+
+/* Contains the current state of a running pipeline.
  */
 typedef struct vertex_buffer
 {
-   /* Backpointers.
+   /* Constant over life of the vertex_buffer.
     */
-   struct __GLcontextRec *ctx;
-   struct tnl_context *tnlctx;
+   GLuint Size;
 
-   /* Driver_data is allocated in Driver.RegisterVB(), if required.
+   /* Constant over the pipeline.
     */
-   void *driver_data;
+   GLuint     Count;		                /* for everything except Elts */
+   GLuint     FirstClipped;	                /* temp verts for clipping */
+   GLuint     FirstPrimitive;	                /* usually zero */
 
-   /* List of operations to process vertices in current state.
+   /* Pointers to current data.
     */
-   struct gl_pipeline *pipeline;
-
-   /* Temporary storage used by immediate mode functions and various
-    * operations in the pipeline.
+   GLuint      *Elts;		                /* VERT_ELT */
+   GLvector4f  *ObjPtr;		                /* VERT_OBJ */
+   GLvector4f  *EyePtr;		                /* VERT_EYE */
+   GLvector4f  *ClipPtr;	                /* VERT_CLIP */
+   GLvector4f  *ProjectedClipPtr;               /* VERT_CLIP (2) */
+   GLubyte     ClipOrMask;	                /* VERT_CLIP (3) */
+   GLubyte     *ClipMask;		        /* VERT_CLIP (4) */
+   GLvector3f  *NormalPtr;	                /* VERT_NORM */
+   GLfloat     *NormalLengthPtr;                /* VERT_NORM (optional) */
+   GLvector1ub *EdgeFlagPtr;	                /* VERT_EDGE */
+   GLvector4f  *TexCoordPtr[MAX_TEXTURE_UNITS];	/* VERT_TEX_0..n */
+   GLvector1ui *IndexPtr[2];	                /* VERT_INDEX */
+   GLvector4ub *ColorPtr[2];	                /* VERT_RGBA */
+   GLvector4ub *SecondaryColorPtr[2];           /* VERT_SPEC_RGB */
+   GLvector1f  *FogCoordPtr;	                /* VERT_FOG_COORD */
+   GLvector1f  *PointSizePtr;	                /* VERT_POINT_SIZE */
+   GLmaterial (*Material)[2];                   /* VERT_MATERIAL, optional */
+   GLuint      *MaterialMask;	                /* VERT_MATERIAL, optional */
+   GLuint      *Flag;		                /* VERT_* flags, optional */
+   GLuint      *Primitive;	                /* GL_(mode)|PRIM_* flags */
+   GLuint      *PrimitiveLength;	        /* integers */
+
+   
+   GLuint importable_data;
+   void (*import_data)( GLcontext *ctx, GLuint flags, GLuint vecflags );
+   /* Callback to the provider of the untransformed input for the
+    * render stage (or other stages) to call if they need to write into
+    * write-protected arrays, or fixup the stride on input arrays.
+    * 
+    * This is currently only necessary for client arrays that make it
+    * as far down the pipeline as the render stage.
     */
-   struct immediate *IM;	
-   struct vertex_array_pointers store;	
 
-   /* Where to find outstanding untransformed vertices.
-    */
-   struct immediate *prev_buffer;
-
-   GLuint     Type;            /* Either VB_IMMEDIATE or VB_CVA_PRECALC */
-
-   GLuint     Size, Start, Count;
-   GLuint     Free, FirstFree;
-   GLuint     CopyStart;
-   GLuint     Parity, Ovf;
-   GLuint     PurgeFlags;
-   GLuint     IndirectCount;	/* defaults to count */
-   GLuint     OrFlag, SavedOrFlag;
-   GLuint     Tex3Flag, Tex4Flag;
-   GLuint     SavedTex3Flag, SavedTex4Flag;
-   GLuint     EarlyCull;
-   GLuint     Culled, CullDone;
-
-   /* Pointers to input data - default to buffers in 'im' above.
-    */
-   GLvector4f  *ObjPtr;
-   GLvector3f  *NormalPtr;
-   GLvector4ub *ColorPtr;
-   GLvector1ui *IndexPtr;
-   GLvector1ub *EdgeFlagPtr;
-   GLvector4f  *TexCoordPtr[MAX_TEXTURE_UNITS];
-   GLvector1ui *EltPtr;
-   GLvector4ub *SecondaryColorPtr;
-   GLvector1f  *FogCoordPtr;
-   GLuint      *Flag, FlagMax;
-   struct      gl_material (*Material)[2];
-   GLuint      *MaterialMask;
-
-   GLuint      *NextPrimitive;
-   GLuint      *Primitive;
-   GLuint      LastPrimitive;
-
-   GLfloat (*BoundsPtr)[3];	/* Bounds for cull check */
-   GLfloat  *NormalLengthPtr;	/* Array of precomputed inv. normal lengths */
-
-   /* Holds malloced storage for pipeline data not supplied by
-    * the immediate struct.
-    */
-   GLvector4f Eye;
-   GLvector4f Clip;
-   GLvector4f Win;
-   GLvector1f PointSize;
-   GLvector4ub BColor;		/* not used in cva vb's */
-   GLvector1ui BIndex;		/* not used in cva vb's */
-   GLvector4ub BSecondary;	/* not used in cva vb's */
-
-   /* Temporary storage - may point into IM, or be dynamically
-    * allocated (for cva).
+   GLuint LastClipped;
+   void *interpfunc;
+   /* Two pieces of private data from _tnl_render_stage that have no
+    * business being in this struct.
     */
-   GLubyte *ClipMask;
-   GLubyte *UserClipMask;
 
-   /* Internal values.  Where these point depends on whether
-    * there were any identity matrices defined as transformations
-    * in the pipeline.
-    */
-   GLvector4f *EyePtr;
-   GLvector4f *ClipPtr;
-   GLvector4f *Unprojected;
-   GLvector4f *Projected;
-   GLvector4f *CurrentTexCoord;
-   GLuint     *Indirect;           /* For eval rescue and cva render */
-
-   /* Currently active colors
-    */
-   GLvector4ub *Color[2];
-   GLvector1ui *Index[2];
-   GLvector4ub *SecondaryColor[2];
+} TNLvertexbuffer;
 
-   /* Storage for colors which have been lit but not yet fogged.
-    * Required for CVA, just point into store for normal VB's.
-    */
-   GLvector4ub *LitColor[2];
-   GLvector1ui *LitIndex[2];
-   GLvector4ub *LitSecondary[2];
 
-   /* Temporary values used in texgen.
-    */
-   GLfloat (*tmp_f)[3];
-   GLfloat *tmp_m;
 
-   /* Temporary values used in eval.
-    */
-   GLuint *EvaluatedFlags;
+/* Describes an individual operation on the pipeline. 
+ */
+struct gl_pipeline_stage {
+   const char *name;
+   GLuint check_state;		/* All state referenced in check() --
+				 * When is the pipeline_stage struct
+				 * itself invalidated?  Must be
+				 * constant.
+				 */
 
-   /* Not used for cva:
+   /* Usually constant or set by the 'check' callback:
     */
-   GLubyte *NormCullStart;
-   GLubyte *CullMask;	        /* Results of vertex culling */
-   GLubyte *NormCullMask;       /* Compressed onto shared normals */
-
-   GLubyte ClipOrMask;		/* bitwise-OR of all ClipMask[] values */
-   GLubyte ClipAndMask;		/* bitwise-AND of all ClipMask[] values */
-   GLubyte CullFlag[2];
-   GLubyte CullMode;		/* see flags below */
-
-   GLuint CopyCount;		/* max 3 vertices to copy after transform */
-   GLuint Copy[3];
-   GLfloat CopyProj[3][4];	/* temporary store for projected clip coords */
-
-   /* Hooks for module private data
+   GLuint run_state;		/* All state referenced in run() --
+				 * When is the cached output of the
+				 * stage invalidated?  
+				 */
+   
+   GLboolean active;		/* True if runnable in current state */
+   GLuint inputs;		/* VERT_* inputs to the stage */
+   GLuint outputs;		/* VERT_* outputs of the stage */
+
+   /* Set in _tnl_run_pipeline():
     */
-   void *swsetup_vb;
-
-} TNLvertexbuffer;
-
-
-typedef void (*shade_func)( struct vertex_buffer *VB );
-
-typedef void (*clip_interp_func)( struct vertex_buffer *VB, GLuint dst,
-                                  GLfloat t, GLuint in, GLuint out );
-
-typedef GLuint (*clip_line_func)( struct vertex_buffer *VB,
-				  GLuint *i, GLuint *j,
-				  GLubyte mask);
-
-typedef GLuint (*clip_poly_func)( struct vertex_buffer *VB,
-				  GLuint n, GLuint vlist[],
-				  GLubyte mask );
-
+   GLuint changed_inputs;	/* Generated value -- inputs to the
+				 * stage that have changed since last
+				 * call to 'run'. 
+				 */
 
-#define MAX_PIPELINE_STAGES     30
-
-#define PIPE_IMMEDIATE          0x1
-#define PIPE_PRECALC            0x2
-
-#define PIPE_OP_VERT_XFORM        0x1
-#define PIPE_OP_NORM_XFORM        0x2
-#define PIPE_OP_LIGHT             0x4
-#define PIPE_OP_FOG               0x8
-#define PIPE_OP_TEX              0x10
-#define PIPE_OP_RAST_SETUP_0    0x100
-#define PIPE_OP_RAST_SETUP_1    0x200
-#define PIPE_OP_RENDER          0x400
-#define PIPE_OP_CVA_PREPARE     0x800
-#define PIPE_OP_POINT_SIZE     0x1000
+   /* Private data for the pipeline stage:
+    */
+   void *private;
 
+   /* Free private data.  May not be null.
+    */
+   void (*destroy)( struct gl_pipeline_stage * );
 
-struct gl_pipeline_stage {
-   const char *name;
-   GLuint ops;			/* PIPE_OP flags */
-   GLuint type;			/* VERT flags */
-   GLuint special;		/* VERT flags - force update_inputs() */
-   GLuint state_change;	        /* state flags - trigger update_inputs() */
-   GLuint cva_state_change;          /* state flags - recalc cva buffer */
-   GLuint elt_forbidden_inputs;      /* VERT flags - force a pipeline recalc */
-   GLuint pre_forbidden_inputs;	     /* VERT flags - force a pipeline recalc */
-   GLuint active;		     /* VERT flags */
-   GLuint inputs;		     /* VERT flags */
-   GLuint outputs;		     /* VERT flags */
+   /* Called from _tnl_validate_pipeline().  Must update all fields in
+    * the pipeline_stage struct for the current state. 
+    */
    void (*check)( GLcontext *ctx, struct gl_pipeline_stage * );
-   void (*run)( struct vertex_buffer *VB );
+
+   /* Called from _tnl_run_pipeline().  The stage.changed_inputs value
+    * encodes all inputs to thee struct which have changed.  If
+    * non-zero, recompute all affected outputs of the stage, otherwise
+    * execute any 'sideeffects' of the stage.  
+    *
+    * Return value: GL_TRUE - keep going
+    *               GL_FALSE - finished pipeline
+    */
+   GLboolean (*run)( GLcontext *ctx, struct gl_pipeline_stage * );
 };
 
 
 struct gl_pipeline {
-   GLuint state_change;		/* state changes which require recalc */
-   GLuint cva_state_change;	/* ... which require re-run */
-   GLuint forbidden_inputs;	/* inputs which require recalc */
-   GLuint ops;			/* what gets done in this pipe */
-   GLuint changed_ops;
-   GLuint inputs;
-   GLuint outputs;
-   GLuint new_inputs;
-   GLuint new_outputs;
-   GLuint fallback;
-   GLuint type;
-   GLuint pipeline_valid:1;
-   GLuint data_valid:1;
-   GLuint copy_transformed_data:1;
-   GLuint replay_copied_vertices:1;
-   GLuint new_state;		/* state changes since last recalc */
-   struct gl_pipeline_stage *stages[MAX_PIPELINE_STAGES];
+   GLuint build_state_trigger;	  /* state changes which require build */
+   GLuint build_state_changes;    /* state changes since last build */
+   GLuint run_state_changes;	  /* state changes since last run */
+   GLuint run_input_changes;	  /* VERT_* changes since last run */
+   GLuint inputs;		  /* VERT_* inputs to pipeline */
+   struct gl_pipeline_stage stages[MAX_PIPELINE_STAGES];
+   GLuint nr_stages;
 };
 
 
+struct tnl_eval_store {
+   GLuint EvalMap1Flags;
+   GLuint EvalMap2Flags;
+   GLuint EvalNewState;
 
-/* All fields are derived.
- */
-struct gl_cva {
-   struct gl_pipeline pre;
-   struct gl_pipeline elt;
-	
-   struct gl_client_array Elt;
-   trans_1ui_func EltFunc;
-
-   struct vertex_buffer *VB;
-   struct vertex_arrays v;
-   struct vertex_data store;
-
-   GLuint elt_count;
-   GLenum elt_mode;
-   GLuint elt_size;
-
-   GLuint forbidden_inputs;
-   GLuint orflag;
-   GLuint merge;
-
-   GLuint locked;
-   GLuint lock_changed;
-   GLuint last_orflag;
-   GLuint last_array_flags;
-   GLuint last_array_new_state;
-};
-
-/* These are used to make the ctx->Current values look like
- * arrays (with zero StrideB).
- */
-struct gl_fallback_arrays {
-   struct gl_client_array Normal;
-   struct gl_client_array Color;
-   struct gl_client_array SecondaryColor;
-   struct gl_client_array FogCoord;
-   struct gl_client_array Index;
-   struct gl_client_array TexCoord[MAX_TEXTURE_UNITS];
-   struct gl_client_array EdgeFlag;
+   GLfloat Obj[IMM_SIZE][4];	  
+   GLfloat TexCoord[IMM_SIZE][4];  
+   GLfloat Normal[IMM_SIZE][3];
+   GLchan  Color[IMM_SIZE][4];	  
+   GLuint  Index[IMM_SIZE];
+   GLuint  Flag[IMM_SIZE];
+   GLuint  Elts[IMM_SIZE];
 };
 
+typedef struct {	
 
-
-typedef void (*texgen_func)( struct vertex_buffer *VB,
-			     GLuint textureSet);
-
-
-
-typedef struct tnl_context {	
-
-   GLuint _ArrayFlag[VB_SIZE];	/* crock */
-   GLuint _ArrayFlags;
-   GLuint _ArraySummary;	/* Like flags, but no size information */
-   GLuint _ArrayNewState;	/* Tracks which arrays have been changed. */
-   GLuint _ArrayTex3Flag;
-   GLuint _ArrayTex4Flag;
-
-
-   /* Pipeline stages - shared between the two pipelines,
-    * which live in CVA.
-    */
-   struct gl_pipeline_stage PipelineStage[MAX_PIPELINE_STAGES];
-   GLuint NrPipelineStages;
-
-   /* Per-texunit derived state.
+   /* Track whether the module is active.
     */
-   GLuint _TexgenSize[MAX_TEXTURE_UNITS];
-   GLuint _TexgenHoles[MAX_TEXTURE_UNITS];
-   texgen_func *_TexgenFunc[MAX_TEXTURE_UNITS];
-
+   GLboolean bound_exec;
 
    /* Display list extensions
     */
    GLuint opcode_vertex_cassette;
 
-   /* Cva
+   /* Pipeline
     */
-   struct gl_cva CVA;
-   GLboolean CompileCVAFlag;
+   struct gl_pipeline pipeline;
+   struct vertex_buffer vb;
 
-   clip_poly_func *_poly_clip_tab;
-   clip_line_func *_line_clip_tab;
-   clip_interp_func _ClipInterpFunc; /* Clip interpolation function */
-   normal_func *_NormalTransform; 
-   shade_func *_shade_func_tab;   /* Current shading function table */
-
-   GLenum _CurrentPrimitive;         /* Prim or GL_POLYGON+1 */
-   GLuint _CurrentTex3Flag;
-   GLuint _CurrentTex4Flag;
+   /* GLvectors for binding to vb:
+    */
+   struct vertex_arrays imm_inputs;
+   struct vertex_arrays array_inputs;
+   GLuint *tmp_primitive;
+   GLuint *tmp_primitive_length;
 
-   GLboolean _ReplayHardBeginEnd; /* Display list execution of rect, etc */
+   /* Set when executing an internally generated immediate.
+    */
+   GLboolean ReplayHardBeginEnd;    
+   GLenum CurrentPrimitive;
 
-   GLuint _RenderFlags;	      /* Active inputs to render stage */
+   /* Note which vertices need copying over succesive immediates.
+    * Will add save versions to precompute vertex copying where
+    * possible.
+    */
+   struct immediate *ExecCopySource; 
+   GLuint ExecCopyCount;
+   GLuint ExecCopyElts[IMM_MAX_COPIED_VERTS];
+   GLuint ExecCopyTexSize;
+   GLuint ExecParity;
 
-   /* Cache of unused immediate structs */
-   struct immediate *freed_im_queue;
-   GLuint nr_im_queued;
+   GLuint DlistPrimitive;
+   GLuint DlistPrimitiveLength;
+   GLuint DlistLastPrimitive;
 
-   struct gl_fallback_arrays Fallback; 
+   /* Derived state and storage for _tnl_eval_vb:
+    */
+   struct tnl_eval_store eval;
 
+   /* Functions to be plugged into dispatch when tnl is active.
+    */
    GLvertexformat vtxfmt;
 
 } TNLcontext;
@@ -598,20 +418,16 @@ typedef struct tnl_context {
 
 #define TNL_CONTEXT(ctx) ((TNLcontext *)(ctx->swtnl_context))
 #define TNL_CURRENT_IM(ctx) ((struct immediate *)(ctx->swtnl_im))
-#define TNL_VB(ctx) ((struct vertex_buffer *)(ctx->swtnl_vb))
 
-extern GLboolean _tnl_flush_vertices( GLcontext *ctx, GLuint flush_flags );
 
+#define TYPE_IDX(t) ((t) & 0xf)
+#define MAX_TYPES TYPE_IDX(GL_DOUBLE)+1      /* 0xa + 1 */
 
-extern void
-_tnl_MakeCurrent( GLcontext *ctx,
-		  GLframebuffer *drawBuffer,
-		  GLframebuffer *readBuffer );
+extern void _tnl_MakeCurrent( GLcontext *ctx,
+			      GLframebuffer *drawBuffer,
+			      GLframebuffer *readBuffer );
 
 
-extern void
-_tnl_LightingSpaceChange( GLcontext *ctx );
-
 /*
  * Macros for fetching current input buffer.
  */
@@ -628,4 +444,5 @@ do {						\
 } while (0)
 #endif
 
+
 #endif