src/mesa/tnl/t_context.h

   1 /* $Id: t_context.h,v 1.42 2002/06/23 02:32:39 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  4.1
   6  *
   7  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27 /**
  28  * \file t_context.h
  29  * \brief TnL module datatypes and definitions.
  30  * \author Keith Whitwell
  31  */
  32
  33 #ifndef _T_CONTEXT_H
  34 #define _T_CONTEXT_H
  35
  36 #include "glheader.h"
  37 #include "mtypes.h"
  38
  39 #include "math/m_matrix.h"
  40 #include "math/m_vector.h"
  41 #include "math/m_xform.h"
  42
  43
  44 #define MAX_PIPELINE_STAGES     30
  45
  46
  47 /* Numbers for sizing immediate structs.
  48  */
  49 #define IMM_MAX_COPIED_VERTS  3
  50 #define IMM_MAXDATA          (216 + IMM_MAX_COPIED_VERTS)
  51 #define IMM_SIZE             (IMM_MAXDATA + MAX_CLIPPED_VERTICES)
  52
  53
  54 /* Values for IM->BeginState
  55  */
  56 #define VERT_BEGIN_0    0x1        /* glBegin (if initially inside beg/end) */
  57 #define VERT_BEGIN_1    0x2        /* glBegin (if initially outside beg/end) */
  58 #define VERT_ERROR_0    0x4        /* invalid_operation in initial state 0 */
  59 #define VERT_ERROR_1    0x8        /* invalid_operation in initial state 1 */
  60
  61
  62 /* Flags to be added to the primitive enum in VB->Primitive.
  63  */
  64 #define PRIM_MODE_MASK  0xff   /* Extract the actual primitive */
  65 #define PRIM_BEGIN      0x100  /* The prim starts here (not wrapped) */
  66 #define PRIM_END        0x200  /* The prim ends in this VB (does not wrap) */
  67 #define PRIM_PARITY     0x400  /* The prim wrapped on an odd number of verts */
  68 #define PRIM_LAST       0x800  /* No more prims in the VB */
  69
  70
  71 /**
  72  * Flags that describe the inputs and outputs of pipeline stages, and
  73  * the contents of a vertex-cassette.  We reuse the VERT_BIT_* flags
  74  * defined in mtypes.h and add a bunch of new ones.
  75  */
  76 /* bits 0..5 defined in mtypes.h */
  77 #define VERT_BIT_INDEX       VERT_BIT_SIX    /* a free vertex attrib bit */
  78 #define VERT_BIT_EDGEFLAG    VERT_BIT_SEVEN  /* a free vertex attrib bit */
  79 /* bits 8..15 defined in mtypes.h */
  80 #define VERT_BIT_EVAL_C1     (1 << 16)  /* imm only */
  81 #define VERT_BIT_EVAL_C2     (1 << 17)  /* imm only */
  82 #define VERT_BIT_EVAL_P1     (1 << 18)  /* imm only */
  83 #define VERT_BIT_EVAL_P2     (1 << 19)  /* imm only */
  84 #define VERT_BIT_OBJ_3       (1 << 20)  /* imm only */
  85 #define VERT_BIT_OBJ_4       (1 << 21)  /* imm only */
  86 #define VERT_BIT_MATERIAL    (1 << 22)  /* imm only, but tested in vb code */
  87 #define VERT_BIT_ELT         (1 << 23)  /* imm only */
  88 #define VERT_BIT_BEGIN       (1 << 24)  /* imm only, but tested in vb code */
  89 #define VERT_BIT_END         (1 << 25)  /* imm only, but tested in vb code */
  90 #define VERT_BIT_END_VB      (1 << 26)  /* imm only, but tested in vb code */
  91 #define VERT_BIT_POINT_SIZE  (1 << 27)  /* vb only, could reuse a bit */
  92 #define VERT_BIT_EYE         VERT_BIT_BEGIN /* vb only, reuse imm bit */
  93 #define VERT_BIT_CLIP        VERT_BIT_END   /* vb only, reuse imm bit*/
  94
  95
  96 /*
  97  * XXXX these are temporary - for backward compatibility w/ DRI drivers
  98  */
  99 #define VERT_OBJ             VERT_BIT_POS
 100 #define VERT_RGBA            VERT_BIT_COLOR0
 101 #define VERT_NORM            VERT_BIT_NORMAL
 102 #define VERT_INDEX           VERT_BIT_INDEX
 103 #define VERT_EDGE            VERT_BIT_SEVEN
 104 #define VERT_SPEC_RGB        VERT_BIT_COLOR1
 105 #define VERT_FOG_COORD       VERT_BIT_FOG
 106 #define VERT_TEX0            VERT_BIT_TEX0
 107 #define VERT_TEX1            VERT_BIT_TEX1
 108 #define VERT_TEX2            VERT_BIT_TEX2
 109 #define VERT_TEX3            VERT_BIT_TEX3
 110 #define VERT_TEX4            VERT_BIT_TEX4
 111 #define VERT_TEX5            VERT_BIT_TEX5
 112 #define VERT_TEX6            VERT_BIT_TEX6
 113 #define VERT_TEX7            VERT_BIT_TEX7
 114 #define VERT_EVAL_C1         VERT_BIT_EVAL_C1
 115 #define VERT_EVAL_C2         VERT_BIT_EVAL_C2
 116 #define VERT_EVAL_P1         VERT_BIT_EVAL_P1
 117 #define VERT_EVAL_P2         VERT_BIT_EVAL_P2
 118 #define VERT_OBJ_3           VERT_BIT_OBJ_3
 119 #define VERT_OBJ_4           VERT_BIT_OBJ_4
 120 #define VERT_MATERIAL        VERT_BIT_MATERIAL
 121 #define VERT_ELT             VERT_BIT_ELT
 122 #define VERT_BEGIN           VERT_BIT_BEGIN
 123 #define VERT_END             VERT_BIT_END
 124 #define VERT_END_VB          VERT_BIT_END_VB
 125 #define VERT_POINT_SIZE      VERT_BIT_POINT_SIZE
 126 #define VERT_EYE             VERT_BIT_EYE
 127 #define VERT_CLIP            VERT_BIT_CLIP
 128
 129
 130 /* Flags for IM->TexCoordSize.  Enough flags for 16 units.
 131  */
 132 #define TEX_0_SIZE_3          (unsigned)0x1
 133 #define TEX_0_SIZE_4          (unsigned)0x10001
 134 #define TEX_SIZE_3(unit)      (TEX_0_SIZE_3 << (unit))
 135 #define TEX_SIZE_4(unit)      (TEX_0_SIZE_4 << (unit))
 136
 137
 138 /* Shorthands.
 139  */
 140 #define VERT_BITS_OBJ_23   (VERT_BIT_POS | VERT_BIT_OBJ_3)
 141 #define VERT_BITS_OBJ_234  (VERT_BIT_POS | VERT_BIT_OBJ_3 | VERT_BIT_OBJ_4)
 142
 143 #define VERT_BITS_TEX_ANY  (VERT_BIT_TEX0 |     \
 144                             VERT_BIT_TEX1 |     \
 145                             VERT_BIT_TEX2 |     \
 146                             VERT_BIT_TEX3 |     \
 147                             VERT_BIT_TEX4 |     \
 148                             VERT_BIT_TEX5 |     \
 149                             VERT_BIT_TEX6 |     \
 150                             VERT_BIT_TEX7)
 151
 152 #define VERT_BITS_EVAL_ANY (VERT_BIT_EVAL_C1 | VERT_BIT_EVAL_P1 | \
 153                             VERT_BIT_EVAL_C2 | VERT_BIT_EVAL_P2)
 154
 155 #define VERT_BITS_FIXUP    (VERT_BITS_TEX_ANY |         \
 156                             VERT_BIT_COLOR0 |           \
 157                             VERT_BIT_COLOR1 |           \
 158                             VERT_BIT_FOG |              \
 159                             VERT_BIT_INDEX |            \
 160                             VERT_BIT_EDGEFLAG |         \
 161                             VERT_BIT_NORMAL)
 162
 163 #define VERT_BITS_CURRENT_DATA  (VERT_BITS_FIXUP |      \
 164                                  VERT_BIT_MATERIAL)
 165
 166 #define VERT_BITS_DATA     (VERT_BITS_TEX_ANY |         \
 167                             VERT_BIT_COLOR0 |           \
 168                             VERT_BIT_COLOR1 |           \
 169                             VERT_BIT_FOG |              \
 170                             VERT_BIT_INDEX |            \
 171                             VERT_BIT_EDGEFLAG |         \
 172                             VERT_BIT_NORMAL |           \
 173                             VERT_BIT_POS |              \
 174                             VERT_BIT_MATERIAL |         \
 175                             VERT_BIT_ELT |              \
 176                             VERT_BITS_EVAL_ANY)
 177
 178
 179 /**
 180  * KW: Represents everything that can take place between a begin and
 181  * end, and can represent multiple begin/end pairs.  Can be used to
 182  * losslessly encode this information in display lists.
 183  */
 184 struct immediate
 185 {
 186    GLuint id, ref_count;
 187
 188    /* This must be saved when immediates are shared in display lists.
 189     */
 190    GLuint CopyStart, Start, Count;
 191    GLuint LastData;             /* count or count+1 */
 192    GLuint AndFlag, OrFlag;
 193    GLuint TexSize;              /* keep track of texcoord sizes */
 194    GLuint BeginState, SavedBeginState;
 195    GLuint LastPrimitive;
 196
 197    GLuint ArrayEltFlags;        /* precalc'ed for glArrayElt */
 198    GLuint ArrayEltIncr;
 199    GLuint ArrayEltFlush;
 200
 201 #define FLUSH_ELT_EAGER 0x1
 202 #define FLUSH_ELT_LAZY 0x2
 203    GLuint FlushElt;
 204
 205    GLuint MaxTextureUnits;      /* precalc'ed for glMultiTexCoordARB */
 206
 207    /* Temporary values created when vertices are copied into the
 208     * first 3 slots of the struct:
 209     */
 210    GLuint CopyOrFlag;
 211    GLuint CopyAndFlag;
 212    GLuint CopyTexSize;
 213    GLuint Evaluated;
 214
 215
 216    /* allocate storage for these on demand:
 217     */
 218    struct gl_material (*Material)[2];
 219    GLuint *MaterialMask;
 220    GLuint LastMaterial;
 221    GLuint MaterialOrMask;
 222    GLuint MaterialAndMask;
 223
 224    GLuint  Primitive[IMM_SIZE];       /* BEGIN/END */
 225    GLuint  PrimitiveLength[IMM_SIZE]; /* BEGIN/END */
 226    GLuint  Flag[IMM_SIZE];            /* VERT_BIT_* flags */
 227
 228    /* All vertex attributes (position, normal, color, secondary color,
 229     * texcoords, fog coord) are stored in the Attrib[] arrays instead
 230     * of individual arrays as we did prior to Mesa 4.1.
 231     *
 232     * XXX may need to use 32-byte aligned allocation for this!!!
 233     */
 234    GLfloat Attrib[VERT_ATTRIB_MAX][IMM_SIZE][4];  /* GL_NV_vertex_program */
 235
 236    GLfloat *NormalLengthPtr; /* length of normal vectors (display list only) */
 237
 238    GLuint  Elt[IMM_SIZE];
 239    GLubyte EdgeFlag[IMM_SIZE];
 240    GLuint  Index[IMM_SIZE];
 241 };
 242
 243
 244 struct vertex_arrays
 245 {
 246    /* XXX move a bunch of these fields into the Attribs[] array??? */
 247    GLvector4f  Obj;
 248    GLvector4f  Normal;
 249    struct gl_client_array Color;
 250    struct gl_client_array SecondaryColor;
 251    GLvector1ui Index;
 252    GLvector1ub EdgeFlag;
 253    GLvector4f  TexCoord[MAX_TEXTURE_UNITS];
 254    GLvector1ui Elt;
 255    GLvector4f  FogCoord;
 256    GLvector4f  Attribs[VERT_ATTRIB_MAX];
 257 };
 258
 259
 260 /**
 261  * Contains the current state of a running pipeline.
 262  */
 263 typedef struct vertex_buffer
 264 {
 265    /* Constant over life of the vertex_buffer.
 266     */
 267    GLuint Size;
 268
 269    /* Constant over the pipeline.
 270     */
 271    GLuint     Count;                          /* for everything except Elts */
 272    GLuint     FirstClipped;                   /* temp verts for clipping */
 273    GLuint     FirstPrimitive;                 /* usually zero */
 274
 275    /* Pointers to current data.
 276     */
 277    GLuint      *Elts;                           /* VERT_BIT_ELT */
 278    GLvector4f  *ObjPtr;                         /* VERT_BIT_POS */
 279    GLvector4f  *EyePtr;                         /* VERT_BIT_EYE */
 280    GLvector4f  *ClipPtr;                        /* VERT_BIT_CLIP */
 281    GLvector4f  *NdcPtr;                         /* VERT_BIT_CLIP (2) */
 282    GLubyte     ClipOrMask;                      /* VERT_BIT_CLIP (3) */
 283    GLubyte     *ClipMask;                       /* VERT_BIT_CLIP (4) */
 284    GLvector4f  *NormalPtr;                      /* VERT_BIT_NORMAL */
 285    GLfloat     *NormalLengthPtr;                /* VERT_BIT_NORMAL */
 286    GLboolean   *EdgeFlag;                       /* VERT_BIT_EDGEFLAG */
 287    GLvector4f  *TexCoordPtr[MAX_TEXTURE_UNITS]; /* VERT_TEX_0..n */
 288    GLvector1ui *IndexPtr[2];                    /* VERT_BIT_INDEX */
 289    struct gl_client_array *ColorPtr[2];         /* VERT_BIT_COLOR0 */
 290    struct gl_client_array *SecondaryColorPtr[2];/* VERT_BIT_COLOR1 */
 291    GLvector4f  *PointSizePtr;                   /* VERT_BIT_POINT_SIZE */
 292    GLvector4f  *FogCoordPtr;                    /* VERT_BIT_FOG */
 293    struct gl_material (*Material)[2];         /* VERT_BIT_MATERIAL, optional */
 294    GLuint      *MaterialMask;                 /* VERT_BIT_MATERIAL, optional */
 295    GLuint      *Flag;                         /* VERT_BIT_* flags, optional */
 296    GLuint      *Primitive;                    /* GL_(mode)|PRIM_* flags */
 297    GLuint      *PrimitiveLength;              /* integers */
 298
 299    /* Inputs to the vertex program stage */
 300    GLvector4f *AttribPtr[VERT_ATTRIB_MAX];      /* GL_NV_vertex_program */
 301
 302    GLuint importable_data;
 303    void *import_source;
 304    void (*import_data)( GLcontext *ctx, GLuint flags, GLuint vecflags );
 305    /* Callback to the provider of the untransformed input for the
 306     * render stage (or other stages) to call if they need to write into
 307     * write-protected arrays, or fixup the stride on input arrays.
 308     *
 309     * This is currently only necessary for client arrays that make it
 310     * as far down the pipeline as the render stage.
 311     */
 312
 313    GLuint LastClipped;
 314    /* Private data from _tnl_render_stage that has no business being
 315     * in this struct.
 316     */
 317
 318 } TNLvertexbuffer;
 319
 320
 321
 322 /* Describes an individual operation on the pipeline.
 323  */
 324 struct gl_pipeline_stage {
 325    const char *name;
 326    GLuint check_state;          /* All state referenced in check() --
 327                                  * When is the pipeline_stage struct
 328                                  * itself invalidated?  Must be
 329                                  * constant.
 330                                  */
 331
 332    /* Usually constant or set by the 'check' callback:
 333     */
 334    GLuint run_state;            /* All state referenced in run() --
 335                                  * When is the cached output of the
 336                                  * stage invalidated?
 337                                  */
 338
 339    GLboolean active;            /* True if runnable in current state */
 340    GLuint inputs;               /* VERT_* inputs to the stage */
 341    GLuint outputs;              /* VERT_* outputs of the stage */
 342
 343    /* Set in _tnl_run_pipeline():
 344     */
 345    GLuint changed_inputs;       /* Generated value -- inputs to the
 346                                  * stage that have changed since last
 347                                  * call to 'run'.
 348                                  */
 349
 350    /* Private data for the pipeline stage:
 351     */
 352    void *privatePtr;
 353
 354    /* Free private data.  May not be null.
 355     */
 356    void (*destroy)( struct gl_pipeline_stage * );
 357
 358    /* Called from _tnl_validate_pipeline().  Must update all fields in
 359     * the pipeline_stage struct for the current state.
 360     */
 361    void (*check)( GLcontext *ctx, struct gl_pipeline_stage * );
 362
 363    /* Called from _tnl_run_pipeline().  The stage.changed_inputs value
 364     * encodes all inputs to thee struct which have changed.  If
 365     * non-zero, recompute all affected outputs of the stage, otherwise
 366     * execute any 'sideeffects' of the stage.
 367     *
 368     * Return value: GL_TRUE - keep going
 369     *               GL_FALSE - finished pipeline
 370     */
 371    GLboolean (*run)( GLcontext *ctx, struct gl_pipeline_stage * );
 372 };
 373
 374
 375 struct gl_pipeline {
 376    GLuint build_state_trigger;    /* state changes which require build */
 377    GLuint build_state_changes;    /* state changes since last build */
 378    GLuint run_state_changes;      /* state changes since last run */
 379    GLuint run_input_changes;      /* VERT_* changes since last run */
 380    GLuint inputs;                 /* VERT_* inputs to pipeline */
 381    struct gl_pipeline_stage stages[MAX_PIPELINE_STAGES+1];
 382    GLuint nr_stages;
 383 };
 384
 385
 386 struct tnl_eval_store {
 387    GLuint EvalMap1Flags;
 388    GLuint EvalMap2Flags;
 389    GLuint EvalMap1AttribFlags;  /* GL_NV_vertex_program */
 390    GLuint EvalMap2AttribFlags;  /* GL_NV_vertex_program */
 391    GLuint EvalNewState;
 392    struct immediate *im;        /* used for temporary data */
 393 };
 394
 395
 396 typedef void (*points_func)( GLcontext *ctx, GLuint first, GLuint last );
 397 typedef void (*line_func)( GLcontext *ctx, GLuint v1, GLuint v2 );
 398 typedef void (*triangle_func)( GLcontext *ctx,
 399                                GLuint v1, GLuint v2, GLuint v3 );
 400 typedef void (*quad_func)( GLcontext *ctx, GLuint v1, GLuint v2,
 401                            GLuint v3, GLuint v4 );
 402 typedef void (*render_func)( GLcontext *ctx, GLuint start, GLuint count,
 403                              GLuint flags );
 404 typedef void (*interp_func)( GLcontext *ctx,
 405                              GLfloat t, GLuint dst, GLuint out, GLuint in,
 406                              GLboolean force_boundary );
 407 typedef void (*copy_pv_func)( GLcontext *ctx, GLuint dst, GLuint src );
 408 typedef void (*setup_func)( GLcontext *ctx,
 409                             GLuint start, GLuint end,
 410                             GLuint new_inputs);
 411
 412
 413 struct tnl_device_driver {
 414    /***
 415     *** TNL Pipeline
 416     ***/
 417
 418    void (*RunPipeline)(GLcontext *ctx);
 419    /* Replaces PipelineStart/PipelineFinish -- intended to allow
 420     * drivers to wrap _tnl_run_pipeline() with code to validate state
 421     * and grab/release hardware locks.
 422     */
 423
 424    void (*NotifyMaterialChange)(GLcontext *ctx);
 425    /* Alert tnl-aware drivers of changes to material.
 426     */
 427
 428    GLboolean (*NotifyBegin)(GLcontext *ctx, GLenum p);
 429    /* Allow drivers to hook in optimized begin/end engines.
 430     * Return value:  GL_TRUE - driver handled the begin
 431     *                GL_FALSE - driver didn't handle the begin
 432     */
 433
 434    /***
 435     *** Rendering -- These functions called only from t_vb_render.c
 436     ***/
 437    struct {
 438       void (*Start)(GLcontext *ctx);
 439       void (*Finish)(GLcontext *ctx);
 440       /* Called before and after all rendering operations, including DrawPixels,
 441        * ReadPixels, Bitmap, span functions, and CopyTexImage, etc commands.
 442        * These are a suitable place for grabbing/releasing hardware locks.
 443        */
 444
 445       void (*PrimitiveNotify)(GLcontext *ctx, GLenum mode);
 446       /* Called between RenderStart() and RenderFinish() to indicate the
 447        * type of primitive we're about to draw.  Mode will be one of the
 448        * modes accepted by glBegin().
 449        */
 450
 451       interp_func Interp;
 452       /* The interp function is called by the clipping routines when we need
 453        * to generate an interpolated vertex.  All pertinant vertex ancilliary
 454        * data should be computed by interpolating between the 'in' and 'out'
 455        * vertices.
 456        */
 457
 458       copy_pv_func CopyPV;
 459       /* The copy function is used to make a copy of a vertex.  All pertinant
 460        * vertex attributes should be copied.
 461        */
 462
 463       void (*ClippedPolygon)( GLcontext *ctx, const GLuint *elts, GLuint n );
 464       /* Render a polygon with <n> vertices whose indexes are in the <elts>
 465        * array.
 466        */
 467
 468       void (*ClippedLine)( GLcontext *ctx, GLuint v0, GLuint v1 );
 469       /* Render a line between the two vertices given by indexes v0 and v1. */
 470
 471       points_func           Points; /* must now respect vb->elts */
 472       line_func             Line;
 473       triangle_func         Triangle;
 474       quad_func             Quad;
 475       /* These functions are called in order to render points, lines,
 476        * triangles and quads.  These are only called via the T&L module.
 477        */
 478
 479       render_func          *PrimTabVerts;
 480       render_func          *PrimTabElts;
 481       /* Render whole unclipped primitives (points, lines, linestrips,
 482        * lineloops, etc).  The tables are indexed by the GL enum of the
 483        * primitive to be rendered.  RenderTabVerts is used for non-indexed
 484        * arrays of vertices.  RenderTabElts is used for indexed arrays of
 485        * vertices.
 486        */
 487
 488       void (*ResetLineStipple)( GLcontext *ctx );
 489       /* Reset the hardware's line stipple counter.
 490        */
 491
 492       setup_func BuildVertices;
 493       /* This function is called whenever new vertices are required for
 494        * rendering.  The vertices in question are those n such that start
 495        * <= n < end.  The new_inputs parameter indicates those fields of
 496        * the vertex which need to be updated, if only a partial repair of
 497        * the vertex is required.
 498        *
 499        * This function is called only from _tnl_render_stage in tnl/t_render.c.
 500        */
 501
 502
 503       GLboolean (*Multipass)( GLcontext *ctx, GLuint passno );
 504       /* Driver may request additional render passes by returning GL_TRUE
 505        * when this function is called.  This function will be called
 506        * after the first pass, and passes will be made until the function
 507        * returns GL_FALSE.  If no function is registered, only one pass
 508        * is made.
 509        *
 510        * This function will be first invoked with passno == 1.
 511        */
 512    } Render;
 513 };
 514
 515
 516 typedef struct {
 517
 518    /* Driver interface.
 519     */
 520    struct tnl_device_driver Driver;
 521
 522    /* Track whether the module is active.
 523     */
 524    GLboolean bound_exec;
 525
 526    /* Display list extensions
 527     */
 528    GLuint opcode_vertex_cassette;
 529
 530    /* Pipeline
 531     */
 532    struct gl_pipeline pipeline;
 533    struct vertex_buffer vb;
 534
 535    /* GLvectors for binding to vb:
 536     */
 537    struct vertex_arrays imm_inputs;
 538    struct vertex_arrays array_inputs;
 539    GLuint *tmp_primitive;
 540    GLuint *tmp_primitive_length;
 541
 542    /* Set when executing an internally generated begin/end object.  If
 543     * such an object is encountered in a display list, it will be
 544     * replayed only if the list is outside any existing begin/end
 545     * objects.
 546     */
 547    GLboolean ReplayHardBeginEnd;
 548
 549    /* Note which vertices need copying over succesive immediates.
 550     * Will add save versions to precompute vertex copying where
 551     * possible.
 552     */
 553    struct immediate *ExecCopySource;
 554    GLuint ExecCopyCount;
 555    GLuint ExecCopyElts[IMM_MAX_COPIED_VERTS];
 556    GLuint ExecCopyTexSize;
 557    GLuint ExecParity;
 558
 559    GLuint DlistPrimitive;
 560    GLuint DlistPrimitiveLength;
 561    GLuint DlistLastPrimitive;
 562
 563    /* Cache a single free immediate (refcount == 0)
 564     */
 565    struct immediate *freed_immediate;
 566
 567    /* Probably need a better configuration mechanism:
 568     */
 569    GLboolean NeedNdcCoords;
 570    GLboolean LoopbackDListCassettes;
 571    GLboolean CalcDListNormalLengths;
 572    GLboolean IsolateMaterials;
 573
 574    /* Derived state and storage for _tnl_eval_vb:
 575     */
 576    struct tnl_eval_store eval;
 577
 578    /* Functions to be plugged into dispatch when tnl is active.
 579     */
 580    GLvertexformat vtxfmt;
 581    GLvertexformat save_vtxfmt;
 582
 583 } TNLcontext;
 584
 585
 586
 587 #define TNL_CONTEXT(ctx) ((TNLcontext *)(ctx->swtnl_context))
 588 #define TNL_CURRENT_IM(ctx) ((struct immediate *)(ctx->swtnl_im))
 589
 590
 591 #define TYPE_IDX(t) ((t) & 0xf)
 592 #define MAX_TYPES TYPE_IDX(GL_DOUBLE)+1      /* 0xa + 1 */
 593
 594 extern void _tnl_MakeCurrent( GLcontext *ctx,
 595                               GLframebuffer *drawBuffer,
 596                               GLframebuffer *readBuffer );
 597
 598
 599 /*
 600  * Macros for fetching current input buffer.
 601  */
 602 #ifdef THREADS
 603 #define GET_IMMEDIATE  struct immediate *IM = TNL_CURRENT_IM(((GLcontext *) (_glapi_Context ? _glapi_Context : _glapi_get_context())))
 604 #define SET_IMMEDIATE(ctx, im)  ctx->swtnl_im = (void *)im
 605 #else
 606 extern struct immediate *_tnl_CurrentInput;
 607 #define GET_IMMEDIATE struct immediate *IM = _tnl_CurrentInput
 608 #define SET_IMMEDIATE(ctx, im)                  \
 609 do {                                            \
 610    ctx->swtnl_im = (void *)im;                  \
 611    _tnl_CurrentInput = im;                      \
 612 } while (0)
 613 #endif
 614
 615
 616 #endif