diff options
Diffstat (limited to 'src/mesa/tnl/t_context.h')
| -rw-r--r-- | src/mesa/tnl/t_context.h | 729 |
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 |