/*
 * Mesa 3-D graphics library
 * Version:  4.0
 *
 * Copyright (C) 1999-2001  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.
 */

/* Authors:
 *    Keith Whitwell <keith@tungstengraphics.com>
 *    Daniel Borca <dborca@users.sourceforge.net>
 */

#include "glheader.h"

#ifdef FX

#include "main/imports.h"
#include "main/mtypes.h"
#include "main/macros.h"
#include "main/colormac.h"
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
#include "tnl/t_context.h"
#include "tnl/t_pipeline.h"

#include "fxdrv.h"


static GLboolean fxMultipass_ColorSum (GLcontext *ctx, GLuint pass);


/*
 * Subpixel offsets to adjust Mesa's (true) window coordinates to
 * Glide coordinates.  We need these to ensure precise rasterization.
 * Otherwise, we'll fail a bunch of conformance tests.
 */
#define TRI_X_OFFSET    ( 0.0F)
#define TRI_Y_OFFSET    ( 0.0F)
#define LINE_X_OFFSET   ( 0.0F)
#define LINE_Y_OFFSET   ( 0.125F)
#define PNT_X_OFFSET    ( 0.375F)
#define PNT_Y_OFFSET    ( 0.375F)

static void fxRasterPrimitive( GLcontext *ctx, GLenum prim );
static void fxRenderPrimitive( GLcontext *ctx, GLenum prim );

static GLenum reduced_prim[GL_POLYGON+1] = {
   GL_POINTS,
   GL_LINES,
   GL_LINES,
   GL_LINES,
   GL_TRIANGLES,
   GL_TRIANGLES,
   GL_TRIANGLES,
   GL_TRIANGLES,
   GL_TRIANGLES,
   GL_TRIANGLES
};

/***********************************************************************
 *          Macros for t_dd_tritmp.h to draw basic primitives          *
 ***********************************************************************/

#define TRI( a, b, c )				\
do {						\
   if (DO_FALLBACK)				\
      fxMesa->draw_tri( fxMesa, a, b, c );	\
   else						\
      grDrawTriangle( a, b, c );	\
} while (0)					\

#define QUAD( a, b, c, d )			\
do {						\
   if (DO_FALLBACK) {				\
      fxMesa->draw_tri( fxMesa, a, b, d );	\
      fxMesa->draw_tri( fxMesa, b, c, d );	\
   } else {					\
      GrVertex *_v_[4];				\
      _v_[0] = d;				\
      _v_[1] = a;				\
      _v_[2] = b;				\
      _v_[3] = c;				\
      grDrawVertexArray(GR_TRIANGLE_FAN, 4, _v_);\
      /*grDrawTriangle( a, b, d );*/		\
      /*grDrawTriangle( b, c, d );*/		\
   }						\
} while (0)

#define LINE( v0, v1 )				\
do {						\
   if (DO_FALLBACK)				\
      fxMesa->draw_line( fxMesa, v0, v1 );	\
   else {					\
      v0->x += LINE_X_OFFSET - TRI_X_OFFSET;	\
      v0->y += LINE_Y_OFFSET - TRI_Y_OFFSET;	\
      v1->x += LINE_X_OFFSET - TRI_X_OFFSET;	\
      v1->y += LINE_Y_OFFSET - TRI_Y_OFFSET;	\
      grDrawLine( v0, v1 );	\
      v0->x -= LINE_X_OFFSET - TRI_X_OFFSET;	\
      v0->y -= LINE_Y_OFFSET - TRI_Y_OFFSET;	\
      v1->x -= LINE_X_OFFSET - TRI_X_OFFSET;	\
      v1->y -= LINE_Y_OFFSET - TRI_Y_OFFSET;	\
   }						\
} while (0)

#define POINT( v0 )				\
do {						\
   if (DO_FALLBACK)				\
      fxMesa->draw_point( fxMesa, v0 );		\
   else {					\
      v0->x += PNT_X_OFFSET - TRI_X_OFFSET;	\
      v0->y += PNT_Y_OFFSET - TRI_Y_OFFSET;	\
      grDrawPoint( v0 );		\
      v0->x -= PNT_X_OFFSET - TRI_X_OFFSET;	\
      v0->y -= PNT_Y_OFFSET - TRI_Y_OFFSET;	\
   }						\
} while (0)


/***********************************************************************
 *              Fallback to swrast for basic primitives                *
 ***********************************************************************/

/* Build an SWvertex from a hardware vertex.
 *
 * This code is hit only when a mix of accelerated and unaccelerated
 * primitives are being drawn, and only for the unaccelerated
 * primitives.
 */
static void
fx_translate_vertex( GLcontext *ctx, const GrVertex *src, SWvertex *dst)
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GLuint ts0 = fxMesa->tmu_source[0];
   GLuint ts1 = fxMesa->tmu_source[1];
   GLfloat w = 1.0F / src->oow;

   dst->win[0] = src->x;
   dst->win[1] = src->y;
   dst->win[2] = src->ooz;
   dst->win[3] = src->oow;

#if FX_PACKEDCOLOR
   dst->color[0] = src->pargb[2];
   dst->color[1] = src->pargb[1];
   dst->color[2] = src->pargb[0];
   dst->color[3] = src->pargb[3];

   dst->specular[0] = src->pspec[2];
   dst->specular[1] = src->pspec[1];
   dst->specular[2] = src->pspec[0];
#else  /* !FX_PACKEDCOLOR */
   dst->color[0] = src->r;
   dst->color[1] = src->g;
   dst->color[2] = src->b;
   dst->color[3] = src->a;

   dst->specular[0] = src->r1;
   dst->specular[1] = src->g1;
   dst->specular[2] = src->g1;
#endif /* !FX_PACKEDCOLOR */

   dst->texcoord[ts0][0] = fxMesa->inv_s0scale * src->tmuvtx[0].sow * w;
   dst->texcoord[ts0][1] = fxMesa->inv_t0scale * src->tmuvtx[0].tow * w;

   if (fxMesa->stw_hint_state & GR_STWHINT_W_DIFF_TMU0)
      dst->texcoord[ts0][3] = src->tmuvtx[0].oow * w;
   else
      dst->texcoord[ts0][3] = 1.0F;

   if (fxMesa->SetupIndex & SETUP_TMU1) {
      dst->texcoord[ts1][0] = fxMesa->inv_s1scale * src->tmuvtx[1].sow * w;
      dst->texcoord[ts1][1] = fxMesa->inv_t1scale * src->tmuvtx[1].tow * w;

      if (fxMesa->stw_hint_state & GR_STWHINT_W_DIFF_TMU1)
	 dst->texcoord[ts1][3] = src->tmuvtx[1].oow * w;
      else
	 dst->texcoord[ts1][3] = 1.0F;
   }

   dst->pointSize = src->psize;
}


static void
fx_fallback_tri( fxMesaContext fxMesa,
		   GrVertex *v0,
		   GrVertex *v1,
		   GrVertex *v2 )
{
   GLcontext *ctx = fxMesa->glCtx;
   SWvertex v[3];

   fx_translate_vertex( ctx, v0, &v[0] );
   fx_translate_vertex( ctx, v1, &v[1] );
   fx_translate_vertex( ctx, v2, &v[2] );
   _swrast_Triangle( ctx, &v[0], &v[1], &v[2] );
}


static void
fx_fallback_line( fxMesaContext fxMesa,
		    GrVertex *v0,
		    GrVertex *v1 )
{
   GLcontext *ctx = fxMesa->glCtx;
   SWvertex v[2];
   fx_translate_vertex( ctx, v0, &v[0] );
   fx_translate_vertex( ctx, v1, &v[1] );
   _swrast_Line( ctx, &v[0], &v[1] );
}


static void
fx_fallback_point( fxMesaContext fxMesa,
		     GrVertex *v0 )
{
   GLcontext *ctx = fxMesa->glCtx;
   SWvertex v[1];
   fx_translate_vertex( ctx, v0, &v[0] );
   _swrast_Point( ctx, &v[0] );
}

/***********************************************************************
 *                 Functions to draw basic primitives                  *
 ***********************************************************************/

static void fx_print_vertex( GLcontext *ctx, const GrVertex *v )
{
 fprintf(stderr, "fx_print_vertex:\n");

 fprintf(stderr, "\tvertex at %p\n", (void *) v);

 fprintf(stderr, "\tx %f y %f z %f oow %f\n", v->x, v->y, v->ooz, v->oow);
#if FX_PACKEDCOLOR
 fprintf(stderr, "\tr %d g %d b %d a %d\n", v->pargb[2], v->pargb[1], v->pargb[0], v->pargb[3]);
#else  /* !FX_PACKEDCOLOR */
 fprintf(stderr, "\tr %f g %f b %f a %f\n", v->r, v->g, v->b, v->a);
#endif /* !FX_PACKEDCOLOR */

 fprintf(stderr, "\n");
}

#define DO_FALLBACK 0

/* Need to do clip loop at each triangle when mixing swrast and hw
 * rendering.  These functions are only used when mixed-mode rendering
 * is occurring.
 */
static void fx_draw_triangle( fxMesaContext fxMesa,
				GrVertex *v0,
				GrVertex *v1,
				GrVertex *v2 )
{
   BEGIN_CLIP_LOOP();
   TRI( v0, v1, v2 );
   END_CLIP_LOOP();
}

static void fx_draw_line( fxMesaContext fxMesa,
			    GrVertex *v0,
			    GrVertex *v1 )
{
   /* No support for wide lines (avoid wide/aa line fallback).
    */
   BEGIN_CLIP_LOOP();
   LINE(v0, v1);
   END_CLIP_LOOP();
}

static void fx_draw_point( fxMesaContext fxMesa,
			     GrVertex *v0 )
{
   /* No support for wide points.
    */
   BEGIN_CLIP_LOOP();
   POINT( v0 );
   END_CLIP_LOOP();
}

#ifndef M_2PI
#define M_2PI 6.28318530717958647692528676655901
#endif
#define __GL_COSF cos
#define __GL_SINF sin
static void fx_draw_point_sprite ( fxMesaContext fxMesa,
				   GrVertex *v0, GLfloat psize )
{
 const GLcontext *ctx = fxMesa->glCtx;

 GLfloat radius;
 GrVertex _v_[4];
 GLuint ts0 = fxMesa->tmu_source[0];
 GLuint ts1 = fxMesa->tmu_source[1];
 GLfloat w = v0->oow;
 GLfloat u0scale = fxMesa->s0scale * w;
 GLfloat v0scale = fxMesa->t0scale * w;
 GLfloat u1scale = fxMesa->s1scale * w;
 GLfloat v1scale = fxMesa->t1scale * w;

 radius = psize / 2.0F;
 _v_[0] = *v0;
 _v_[1] = *v0;
 _v_[2] = *v0;
 _v_[3] = *v0;
 /* CLIP_LOOP ?!? */
 /* point coverage? */
 /* we don't care about culling here (see fxSetupCull) */

 if (ctx->Point.SpriteOrigin == GL_UPPER_LEFT) {
    _v_[0].x -= radius;
    _v_[0].y += radius;
    _v_[1].x += radius;
    _v_[1].y += radius;
    _v_[2].x += radius;
    _v_[2].y -= radius;
    _v_[3].x -= radius;
    _v_[3].y -= radius;
 } else {
    _v_[0].x -= radius;
    _v_[0].y -= radius;
    _v_[1].x += radius;
    _v_[1].y -= radius;
    _v_[2].x += radius;
    _v_[2].y += radius;
    _v_[3].x -= radius;
    _v_[3].y += radius;
 }

 if (ctx->Point.CoordReplace[ts0]) {
    _v_[0].tmuvtx[0].sow = 0;
    _v_[0].tmuvtx[0].tow = 0;
    _v_[1].tmuvtx[0].sow = u0scale;
    _v_[1].tmuvtx[0].tow = 0;
    _v_[2].tmuvtx[0].sow = u0scale;
    _v_[2].tmuvtx[0].tow = v0scale;
    _v_[3].tmuvtx[0].sow = 0;
    _v_[3].tmuvtx[0].tow = v0scale;
 }
 if (ctx->Point.CoordReplace[ts1]) {
    _v_[0].tmuvtx[1].sow = 0;
    _v_[0].tmuvtx[1].tow = 0;
    _v_[1].tmuvtx[1].sow = u1scale;
    _v_[1].tmuvtx[1].tow = 0;
    _v_[2].tmuvtx[1].sow = u1scale;
    _v_[2].tmuvtx[1].tow = v1scale;
    _v_[3].tmuvtx[1].sow = 0;
    _v_[3].tmuvtx[1].tow = v1scale;
 }

 grDrawVertexArrayContiguous(GR_TRIANGLE_FAN, 4, _v_, sizeof(GrVertex));
}

static void fx_draw_point_wide ( fxMesaContext fxMesa,
			         GrVertex *v0 )
{
 GLint i, n;
 GLfloat ang, radius, oon;
 GrVertex vtxB, vtxC;
 GrVertex *_v_[3];

 const GLcontext *ctx = fxMesa->glCtx;
 const GLfloat psize = (ctx->_TriangleCaps & DD_POINT_ATTEN)
                       ? CLAMP(v0->psize, ctx->Point.MinSize, ctx->Point.MaxSize)
                       : ctx->Point._Size; /* clamped */

 if (ctx->Point.PointSprite) {
    fx_draw_point_sprite(fxMesa, v0, psize);
    return;
 }

 _v_[0] = v0;
 _v_[1] = &vtxB;
 _v_[2] = &vtxC;

 radius = psize / 2.0F;
 n = IROUND(psize * 2); /* radius x 4 */
 if (n < 4) n = 4;
 oon = 1.0F / (GLfloat)n;

 /* CLIP_LOOP ?!? */
 /* point coverage? */
 /* we don't care about culling here (see fxSetupCull) */

 vtxB = *v0;
 vtxC = *v0;

 vtxB.x += radius;
 ang = M_2PI * oon;
 vtxC.x += radius * __GL_COSF(ang);
 vtxC.y += radius * __GL_SINF(ang);
 grDrawVertexArray(GR_TRIANGLE_FAN, 3, _v_);
 for (i = 2; i <= n; i++) {
     ang = M_2PI * i * oon;
     vtxC.x = v0->x + radius * __GL_COSF(ang);
     vtxC.y = v0->y + radius * __GL_SINF(ang);
     grDrawVertexArray(GR_TRIANGLE_FAN_CONTINUE, 1, &_v_[2]);
 }
}

static void fx_render_pw_verts( GLcontext *ctx,
				GLuint start,
				GLuint count,
				GLuint flags )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GrVertex *fxVB = fxMesa->verts;
   (void) flags;

   fxRenderPrimitive( ctx, GL_POINTS );

   for ( ; start < count ; start++)
      fx_draw_point_wide(fxMesa, fxVB + start);
}

static void fx_render_pw_elts ( GLcontext *ctx,
				GLuint start,
				GLuint count,
				GLuint flags )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GrVertex *fxVB = fxMesa->verts;
   const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts;
   (void) flags;

   fxRenderPrimitive( ctx, GL_POINTS );

   for ( ; start < count ; start++)
      fx_draw_point_wide(fxMesa, fxVB + elt[start]);
}

static void fx_draw_point_wide_aa ( fxMesaContext fxMesa,
			            GrVertex *v0 )
{
 GLint i, n;
 GLfloat ang, radius, oon;
 GrVertex vtxB, vtxC;

 const GLcontext *ctx = fxMesa->glCtx;
 const GLfloat psize = (ctx->_TriangleCaps & DD_POINT_ATTEN)
                       ? CLAMP(v0->psize, ctx->Point.MinSize, ctx->Point.MaxSize)
                       : ctx->Point._Size; /* clamped */

 if (ctx->Point.PointSprite) {
    fx_draw_point_sprite(fxMesa, v0, psize);
    return;
 }

 radius = psize / 2.0F;
 n = IROUND(psize * 2); /* radius x 4 */
 if (n < 4) n = 4;
 oon = 1.0F / (GLfloat)n;

 /* CLIP_LOOP ?!? */
 /* point coverage? */
 /* we don't care about culling here (see fxSetupCull) */

 vtxB = *v0;
 vtxC = *v0;

 vtxB.x += radius;
 for (i = 1; i <= n; i++) {
     ang = M_2PI * i * oon;
     vtxC.x = v0->x + radius * __GL_COSF(ang);
     vtxC.y = v0->y + radius * __GL_SINF(ang);
     grAADrawTriangle( v0, &vtxB, &vtxC, FXFALSE, FXTRUE, FXFALSE);
     /*grDrawTriangle( v0, &vtxB, &vtxC);*/
     vtxB.x = vtxC.x;
     vtxB.y = vtxC.y;
 }
}
#undef __GLCOSF
#undef __GLSINF
#undef M_2PI

#undef DO_FALLBACK


#define FX_UNFILLED_BIT    0x1
#define FX_OFFSET_BIT	   0x2
#define FX_TWOSIDE_BIT     0x4
#define FX_FLAT_BIT        0x8
#define FX_TWOSTENCIL_BIT  0x10
#define FX_FALLBACK_BIT    0x20
#define FX_MAX_TRIFUNC     0x40

static struct {
   tnl_points_func	points;
   tnl_line_func	line;
   tnl_triangle_func	triangle;
   tnl_quad_func	quad;
} rast_tab[FX_MAX_TRIFUNC];

#define DO_FALLBACK (IND & FX_FALLBACK_BIT)
#define DO_OFFSET   (IND & FX_OFFSET_BIT)
#define DO_UNFILLED (IND & FX_UNFILLED_BIT)
#define DO_TWOSIDE  (IND & FX_TWOSIDE_BIT)
#define DO_FLAT     (IND & FX_FLAT_BIT)
#define DO_TWOSTENCIL (IND & FX_TWOSTENCIL_BIT)
#define DO_TRI       1
#define DO_QUAD      1
#define DO_LINE      1
#define DO_POINTS    1
#define DO_FULL_QUAD 1

#define HAVE_RGBA   1
#define HAVE_SPEC   1
#define HAVE_HW_FLATSHADE 0
#define HAVE_BACK_COLORS  0
#define VERTEX GrVertex
#define TAB rast_tab

#define DEPTH_SCALE 1.0
#define UNFILLED_TRI unfilled_tri
#define UNFILLED_QUAD unfilled_quad
#define VERT_X(_v) _v->x
#define VERT_Y(_v) _v->y
#define VERT_Z(_v) _v->ooz
#define AREA_IS_CCW( a ) IS_NEGATIVE( a )
#define GET_VERTEX(e) (fxMesa->verts + e)


#if FX_PACKEDCOLOR
#define VERT_SET_RGBA( dst, f )			\
do {						\
   UNCLAMPED_FLOAT_TO_UBYTE(dst->pargb[2], f[0]);\
   UNCLAMPED_FLOAT_TO_UBYTE(dst->pargb[1], f[1]);\
   UNCLAMPED_FLOAT_TO_UBYTE(dst->pargb[0], f[2]);\
   UNCLAMPED_FLOAT_TO_UBYTE(dst->pargb[3], f[3]);\
} while (0)

#define VERT_COPY_RGBA( v0, v1 ) 		\
   *(GLuint *)&v0->pargb = *(GLuint *)&v1->pargb

#define VERT_SAVE_RGBA( idx )  			\
   *(GLuint *)&color[idx] = *(GLuint *)&v[idx]->pargb

#define VERT_RESTORE_RGBA( idx )		\
   *(GLuint *)&v[idx]->pargb = *(GLuint *)&color[idx]


#define VERT_SET_SPEC( dst, f )			\
do {						\
   UNCLAMPED_FLOAT_TO_UBYTE(dst->pspec[2], f[0]);\
   UNCLAMPED_FLOAT_TO_UBYTE(dst->pspec[1], f[1]);\
   UNCLAMPED_FLOAT_TO_UBYTE(dst->pspec[0], f[2]);\
} while (0)

#define VERT_COPY_SPEC( v0, v1 ) 		\
   *(GLuint *)&v0->pspec = *(GLuint *)&v1->pspec

#define VERT_SAVE_SPEC( idx )  			\
   *(GLuint *)&spec[idx] = *(GLuint *)&v[idx]->pspec

#define VERT_RESTORE_SPEC( idx )		\
   *(GLuint *)&v[idx]->pspec = *(GLuint *)&spec[idx]


#define LOCAL_VARS(n)				\
   fxMesaContext fxMesa = FX_CONTEXT(ctx);	\
   GLubyte color[n][4], spec[n][4];		\
   (void) color; (void) spec;
#else  /* !FX_PACKEDCOLOR */
#define VERT_SET_RGBA( dst, f )	\
do {				\
   CNORM(dst->r, f[0]);		\
   CNORM(dst->g, f[1]);		\
   CNORM(dst->b, f[2]);		\
   CNORM(dst->a, f[3]);		\
} while (0)

#define VERT_COPY_RGBA( v0, v1 ) 		\
do {						\
   COPY_FLOAT(v0->r, v1->r);			\
   COPY_FLOAT(v0->g, v1->g);			\
   COPY_FLOAT(v0->b, v1->b);			\
   COPY_FLOAT(v0->a, v1->a);			\
} while (0)

#define VERT_SAVE_RGBA( idx )  			\
do {						\
   COPY_FLOAT(color[idx][0], v[idx]->r);	\
   COPY_FLOAT(color[idx][1], v[idx]->g);	\
   COPY_FLOAT(color[idx][2], v[idx]->b);	\
   COPY_FLOAT(color[idx][3], v[idx]->a);	\
} while (0)

#define VERT_RESTORE_RGBA( idx )		\
do {						\
   COPY_FLOAT(v[idx]->r, color[idx][0]);	\
   COPY_FLOAT(v[idx]->g, color[idx][1]);	\
   COPY_FLOAT(v[idx]->b, color[idx][2]);	\
   COPY_FLOAT(v[idx]->a, color[idx][3]);	\
} while (0)


#define VERT_SET_SPEC( dst, f )	\
do {				\
   CNORM(dst->r1, f[0]);	\
   CNORM(dst->g1, f[1]);	\
   CNORM(dst->b1, f[2]);	\
} while (0)

#define VERT_COPY_SPEC( v0, v1 ) 		\
do {						\
   COPY_FLOAT(v0->r1, v1->r1);			\
   COPY_FLOAT(v0->g1, v1->g1);			\
   COPY_FLOAT(v0->b1, v1->b1);			\
} while (0)

#define VERT_SAVE_SPEC( idx )  			\
do {						\
   COPY_FLOAT(spec[idx][0], v[idx]->r1);	\
   COPY_FLOAT(spec[idx][1], v[idx]->g1);	\
   COPY_FLOAT(spec[idx][2], v[idx]->b1);	\
} while (0)

#define VERT_RESTORE_SPEC( idx )		\
do {						\
   COPY_FLOAT(v[idx]->r1, spec[idx][0]);	\
   COPY_FLOAT(v[idx]->g1, spec[idx][1]);	\
   COPY_FLOAT(v[idx]->b1, spec[idx][2]);	\
} while (0)


#define LOCAL_VARS(n)				\
   fxMesaContext fxMesa = FX_CONTEXT(ctx);	\
   GLfloat color[n][4], spec[n][4];		\
   (void) color; (void) spec;
#endif /* !FX_PACKEDCOLOR */


/***********************************************************************
 *            Twoside stencil                                          *
 ***********************************************************************/
#define SETUP_STENCIL(f) if (f) fxSetupStencilFace(ctx, f)
#define UNSET_STENCIL(f) if (f) fxSetupStencil(ctx)


/***********************************************************************
 *            Functions to draw basic unfilled primitives              *
 ***********************************************************************/

#define RASTERIZE(x) if (fxMesa->raster_primitive != reduced_prim[x]) \
                        fxRasterPrimitive( ctx, reduced_prim[x] )
#define RENDER_PRIMITIVE fxMesa->render_primitive
#define IND FX_FALLBACK_BIT
#define TAG(x) x
#include "tnl_dd/t_dd_unfilled.h"
#undef IND

/***********************************************************************
 *                 Functions to draw GL primitives                     *
 ***********************************************************************/

#define IND (0)
#define TAG(x) x
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT)
#define TAG(x) x##_offset
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT)
#define TAG(x) x##_twoside
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT)
#define TAG(x) x##_twoside_offset
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_UNFILLED_BIT)
#define TAG(x) x##_unfilled
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_UNFILLED_BIT)
#define TAG(x) x##_offset_unfilled
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_UNFILLED_BIT)
#define TAG(x) x##_twoside_unfilled
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_UNFILLED_BIT)
#define TAG(x) x##_twoside_offset_unfilled
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_FALLBACK_BIT)
#define TAG(x) x##_fallback
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_FALLBACK_BIT)
#define TAG(x) x##_offset_fallback
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_FALLBACK_BIT)
#define TAG(x) x##_twoside_fallback
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_FALLBACK_BIT)
#define TAG(x) x##_twoside_offset_fallback
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_UNFILLED_BIT|FX_FALLBACK_BIT)
#define TAG(x) x##_unfilled_fallback
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_UNFILLED_BIT|FX_FALLBACK_BIT)
#define TAG(x) x##_offset_unfilled_fallback
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_UNFILLED_BIT|FX_FALLBACK_BIT)
#define TAG(x) x##_twoside_unfilled_fallback
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_UNFILLED_BIT| \
	     FX_FALLBACK_BIT)
#define TAG(x) x##_twoside_offset_unfilled_fallback
#include "tnl_dd/t_dd_tritmp.h"


/* Fx doesn't support provoking-vertex flat-shading?
 */
#define IND (FX_FLAT_BIT)
#define TAG(x) x##_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_FLAT_BIT)
#define TAG(x) x##_offset_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_FLAT_BIT)
#define TAG(x) x##_twoside_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_FLAT_BIT)
#define TAG(x) x##_twoside_offset_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_UNFILLED_BIT|FX_FLAT_BIT)
#define TAG(x) x##_unfilled_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_UNFILLED_BIT|FX_FLAT_BIT)
#define TAG(x) x##_offset_unfilled_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_UNFILLED_BIT|FX_FLAT_BIT)
#define TAG(x) x##_twoside_unfilled_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_UNFILLED_BIT|FX_FLAT_BIT)
#define TAG(x) x##_twoside_offset_unfilled_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_FALLBACK_BIT|FX_FLAT_BIT)
#define TAG(x) x##_fallback_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_FALLBACK_BIT|FX_FLAT_BIT)
#define TAG(x) x##_offset_fallback_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_FALLBACK_BIT|FX_FLAT_BIT)
#define TAG(x) x##_twoside_fallback_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_FALLBACK_BIT|FX_FLAT_BIT)
#define TAG(x) x##_twoside_offset_fallback_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_UNFILLED_BIT|FX_FALLBACK_BIT|FX_FLAT_BIT)
#define TAG(x) x##_unfilled_fallback_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_UNFILLED_BIT|FX_FALLBACK_BIT|FX_FLAT_BIT)
#define TAG(x) x##_offset_unfilled_fallback_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_UNFILLED_BIT|FX_FALLBACK_BIT|FX_FLAT_BIT)
#define TAG(x) x##_twoside_unfilled_fallback_flat
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_UNFILLED_BIT| \
	     FX_FALLBACK_BIT|FX_FLAT_BIT)
#define TAG(x) x##_twoside_offset_unfilled_fallback_flat
#include "tnl_dd/t_dd_tritmp.h"


/* 2-sided stencil begin */
#define IND (FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_offset_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_offset_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_UNFILLED_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_unfilled_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_UNFILLED_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_offset_unfilled_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_UNFILLED_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_unfilled_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_UNFILLED_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_offset_unfilled_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_FALLBACK_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_fallback_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_FALLBACK_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_offset_fallback_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_FALLBACK_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_fallback_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_FALLBACK_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_offset_fallback_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_UNFILLED_BIT|FX_FALLBACK_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_unfilled_fallback_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_UNFILLED_BIT|FX_FALLBACK_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_offset_unfilled_fallback_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_UNFILLED_BIT|FX_FALLBACK_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_unfilled_fallback_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_UNFILLED_BIT| \
	     FX_FALLBACK_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_offset_unfilled_fallback_twostencil
#include "tnl_dd/t_dd_tritmp.h"


/* Fx doesn't support provoking-vertex flat-shading?
 */
#define IND (FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_offset_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_offset_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_UNFILLED_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_unfilled_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_UNFILLED_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_offset_unfilled_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_UNFILLED_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_unfilled_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_UNFILLED_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_offset_unfilled_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_FALLBACK_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_fallback_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_FALLBACK_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_offset_fallback_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_FALLBACK_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_fallback_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_FALLBACK_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_offset_fallback_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_UNFILLED_BIT|FX_FALLBACK_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_unfilled_fallback_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_OFFSET_BIT|FX_UNFILLED_BIT|FX_FALLBACK_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_offset_unfilled_fallback_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_UNFILLED_BIT|FX_FALLBACK_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_unfilled_fallback_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"

#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT|FX_UNFILLED_BIT| \
	     FX_FALLBACK_BIT|FX_FLAT_BIT|FX_TWOSTENCIL_BIT)
#define TAG(x) x##_twoside_offset_unfilled_fallback_flat_twostencil
#include "tnl_dd/t_dd_tritmp.h"
/* 2-sided stencil end */


static void init_rast_tab( void )
{
   init();
   init_offset();
   init_twoside();
   init_twoside_offset();
   init_unfilled();
   init_offset_unfilled();
   init_twoside_unfilled();
   init_twoside_offset_unfilled();
   init_fallback();
   init_offset_fallback();
   init_twoside_fallback();
   init_twoside_offset_fallback();
   init_unfilled_fallback();
   init_offset_unfilled_fallback();
   init_twoside_unfilled_fallback();
   init_twoside_offset_unfilled_fallback();

   init_flat();
   init_offset_flat();
   init_twoside_flat();
   init_twoside_offset_flat();
   init_unfilled_flat();
   init_offset_unfilled_flat();
   init_twoside_unfilled_flat();
   init_twoside_offset_unfilled_flat();
   init_fallback_flat();
   init_offset_fallback_flat();
   init_twoside_fallback_flat();
   init_twoside_offset_fallback_flat();
   init_unfilled_fallback_flat();
   init_offset_unfilled_fallback_flat();
   init_twoside_unfilled_fallback_flat();
   init_twoside_offset_unfilled_fallback_flat();

   /* 2-sided stencil begin */
   init_twostencil();
   init_offset_twostencil();
   init_twoside_twostencil();
   init_twoside_offset_twostencil();
   init_unfilled_twostencil();
   init_offset_unfilled_twostencil();
   init_twoside_unfilled_twostencil();
   init_twoside_offset_unfilled_twostencil();
   init_fallback_twostencil();
   init_offset_fallback_twostencil();
   init_twoside_fallback_twostencil();
   init_twoside_offset_fallback_twostencil();
   init_unfilled_fallback_twostencil();
   init_offset_unfilled_fallback_twostencil();
   init_twoside_unfilled_fallback_twostencil();
   init_twoside_offset_unfilled_fallback_twostencil();

   init_flat_twostencil();
   init_offset_flat_twostencil();
   init_twoside_flat_twostencil();
   init_twoside_offset_flat_twostencil();
   init_unfilled_flat_twostencil();
   init_offset_unfilled_flat_twostencil();
   init_twoside_unfilled_flat_twostencil();
   init_twoside_offset_unfilled_flat_twostencil();
   init_fallback_flat_twostencil();
   init_offset_fallback_flat_twostencil();
   init_twoside_fallback_flat_twostencil();
   init_twoside_offset_fallback_flat_twostencil();
   init_unfilled_fallback_flat_twostencil();
   init_offset_unfilled_fallback_flat_twostencil();
   init_twoside_unfilled_fallback_flat_twostencil();
   init_twoside_offset_unfilled_fallback_flat_twostencil();
   /* 2-sided stencil end */
}


/**********************************************************************/
/*                 Render whole begin/end objects                     */
/**********************************************************************/


/* Accelerate vertex buffer rendering when renderindex == 0 and
 * there is no clipping.
 */
#define INIT(x) fxRenderPrimitive( ctx, x )

static void fx_render_vb_points( GLcontext *ctx,
				 GLuint start,
				 GLuint count,
				 GLuint flags )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GrVertex *fxVB = fxMesa->verts;
   GLint i;
   (void) flags;

   if (TDFX_DEBUG & VERBOSE_VARRAY) {
      fprintf(stderr, "fx_render_vb_points\n");
   }

   INIT(GL_POINTS);

   /* Adjust point coords */
   for (i = start; i < count; i++) {
      fxVB[i].x += PNT_X_OFFSET - TRI_X_OFFSET;
      fxVB[i].y += PNT_Y_OFFSET - TRI_Y_OFFSET;
   }

   grDrawVertexArrayContiguous( GR_POINTS, count-start,
                                fxVB + start, sizeof(GrVertex));
   /* restore point coords */
   for (i = start; i < count; i++) {
      fxVB[i].x -= PNT_X_OFFSET - TRI_X_OFFSET;
      fxVB[i].y -= PNT_Y_OFFSET - TRI_Y_OFFSET;
   }
}

static void fx_render_vb_line_strip( GLcontext *ctx,
				     GLuint start,
				     GLuint count,
				     GLuint flags )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GrVertex *fxVB = fxMesa->verts;
   GLint i;
   (void) flags;

   if (TDFX_DEBUG & VERBOSE_VARRAY) {
      fprintf(stderr, "fx_render_vb_line_strip\n");
   }

   INIT(GL_LINE_STRIP);

   /* adjust line coords */
   for (i = start; i < count; i++) {
      fxVB[i].x += LINE_X_OFFSET - TRI_X_OFFSET;
      fxVB[i].y += LINE_Y_OFFSET - TRI_Y_OFFSET;
   }

   grDrawVertexArrayContiguous( GR_LINE_STRIP, count-start,
                                fxVB + start, sizeof(GrVertex));

   /* restore line coords */
   for (i = start; i < count; i++) {
      fxVB[i].x -= LINE_X_OFFSET - TRI_X_OFFSET;
      fxVB[i].y -= LINE_Y_OFFSET - TRI_Y_OFFSET;
   }
}

static void fx_render_vb_line_loop( GLcontext *ctx,
				    GLuint start,
				    GLuint count,
				    GLuint flags )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GrVertex *fxVB = fxMesa->verts;
   GLint i;
   GLint j = start;
   (void) flags;

   if (TDFX_DEBUG & VERBOSE_VARRAY) {
      fprintf(stderr, "fx_render_vb_line_loop\n");
   }

   INIT(GL_LINE_LOOP);

   if (!(flags & PRIM_BEGIN)) {
      j++;
   }

   /* adjust line coords */
   for (i = start; i < count; i++) {
      fxVB[i].x += LINE_X_OFFSET - TRI_X_OFFSET;
      fxVB[i].y += LINE_Y_OFFSET - TRI_Y_OFFSET;
   }

   grDrawVertexArrayContiguous( GR_LINE_STRIP, count-j,
                                fxVB + j, sizeof(GrVertex));

   if (flags & PRIM_END)
      grDrawLine( fxVB + (count - 1),
                  fxVB + start );

   /* restore line coords */
   for (i = start; i < count; i++) {
      fxVB[i].x -= LINE_X_OFFSET - TRI_X_OFFSET;
      fxVB[i].y -= LINE_Y_OFFSET - TRI_Y_OFFSET;
   }
}

static void fx_render_vb_lines( GLcontext *ctx,
				GLuint start,
				GLuint count,
				GLuint flags )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GrVertex *fxVB = fxMesa->verts;
   GLint i;
   (void) flags;

   if (TDFX_DEBUG & VERBOSE_VARRAY) {
      fprintf(stderr, "fx_render_vb_lines\n");
   }

   INIT(GL_LINES);

   /* adjust line coords */
   for (i = start; i < count; i++) {
      fxVB[i].x += LINE_X_OFFSET - TRI_X_OFFSET;
      fxVB[i].y += LINE_Y_OFFSET - TRI_Y_OFFSET;
   }

   grDrawVertexArrayContiguous( GR_LINES, count-start,
                                fxVB + start, sizeof(GrVertex));

   /* restore line coords */
   for (i = start; i < count; i++) {
      fxVB[i].x -= LINE_X_OFFSET - TRI_X_OFFSET;
      fxVB[i].y -= LINE_Y_OFFSET - TRI_Y_OFFSET;
   }
}

static void fx_render_vb_triangles( GLcontext *ctx,
				    GLuint start,
				    GLuint count,
				    GLuint flags )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GrVertex *fxVB = fxMesa->verts;
   GLuint j;
   (void) flags;

   if (TDFX_DEBUG & VERBOSE_VARRAY) {
      fprintf(stderr, "fx_render_vb_triangles\n");
   }

   INIT(GL_TRIANGLES);

   for (j=start+2; j<count; j+=3) {
      grDrawTriangle(fxVB + (j-2), fxVB + (j-1), fxVB + j);
   }
}


static void fx_render_vb_tri_strip( GLcontext *ctx,
				    GLuint start,
				    GLuint count,
				    GLuint flags )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GrVertex *fxVB = fxMesa->verts;
   (void) flags;

   if (TDFX_DEBUG & VERBOSE_VARRAY) {
      fprintf(stderr, "fx_render_vb_tri_strip\n");
   }

   INIT(GL_TRIANGLE_STRIP);

   /* no GR_TRIANGLE_STRIP_CONTINUE?!? */

   grDrawVertexArrayContiguous( GR_TRIANGLE_STRIP, count-start,
                                fxVB + start, sizeof(GrVertex));
}


static void fx_render_vb_tri_fan( GLcontext *ctx,
				  GLuint start,
				  GLuint count,
				  GLuint flags )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GrVertex *fxVB = fxMesa->verts;
   (void) flags;

   if (TDFX_DEBUG & VERBOSE_VARRAY) {
      fprintf(stderr, "fx_render_vb_tri_fan\n");
   }

   INIT(GL_TRIANGLE_FAN);

   grDrawVertexArrayContiguous( GR_TRIANGLE_FAN, count-start,
                                fxVB + start, sizeof(GrVertex) );
}

static void fx_render_vb_quads( GLcontext *ctx,
				GLuint start,
				GLuint count,
				GLuint flags )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GrVertex *fxVB = fxMesa->verts;
   GLuint i;
   (void) flags;

   if (TDFX_DEBUG & VERBOSE_VARRAY) {
      fprintf(stderr, "fx_render_vb_quads\n");
   }

   INIT(GL_QUADS);

   for (i = start + 3 ; i < count ; i += 4 ) {
#define VERT(x) (fxVB + (x))
      GrVertex *_v_[4];
      _v_[0] = VERT(i);
      _v_[1] = VERT(i-3);
      _v_[2] = VERT(i-2);
      _v_[3] = VERT(i-1);
      grDrawVertexArray(GR_TRIANGLE_FAN, 4, _v_);
      /*grDrawTriangle( VERT(i-3), VERT(i-2), VERT(i) );*/
      /*grDrawTriangle( VERT(i-2), VERT(i-1), VERT(i) );*/
#undef VERT
   }
}

static void fx_render_vb_quad_strip( GLcontext *ctx,
				     GLuint start,
				     GLuint count,
				     GLuint flags )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GrVertex *fxVB = fxMesa->verts;
   (void) flags;

   if (TDFX_DEBUG & VERBOSE_VARRAY) {
      fprintf(stderr, "fx_render_vb_quad_strip\n");
   }

   INIT(GL_QUAD_STRIP);

   count -= (count-start)&1;

   grDrawVertexArrayContiguous( GR_TRIANGLE_STRIP,
                                count-start, fxVB + start, sizeof(GrVertex));
}

static void fx_render_vb_poly( GLcontext *ctx,
				GLuint start,
				GLuint count,
				GLuint flags )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GrVertex *fxVB = fxMesa->verts;
   (void) flags;

   if (TDFX_DEBUG & VERBOSE_VARRAY) {
      fprintf(stderr, "fx_render_vb_poly\n");
   }

   INIT(GL_POLYGON);

   grDrawVertexArrayContiguous( GR_POLYGON, count-start,
                                fxVB + start, sizeof(GrVertex));
}

static void fx_render_vb_noop( GLcontext *ctx,
				 GLuint start,
				 GLuint count,
				 GLuint flags )
{
   (void) (ctx && start && count && flags);
}

static void (*fx_render_tab_verts[GL_POLYGON+2])(GLcontext *,
						   GLuint,
						   GLuint,
						   GLuint) =
{
   fx_render_vb_points,
   fx_render_vb_lines,
   fx_render_vb_line_loop,
   fx_render_vb_line_strip,
   fx_render_vb_triangles,
   fx_render_vb_tri_strip,
   fx_render_vb_tri_fan,
   fx_render_vb_quads,
   fx_render_vb_quad_strip,
   fx_render_vb_poly,
   fx_render_vb_noop,
};
#undef INIT


/**********************************************************************/
/*            Render whole (indexed) begin/end objects                */
/**********************************************************************/


#define VERT(x) (vertptr + x)

#define RENDER_POINTS( start, count )		\
   for ( ; start < count ; start++)		\
      grDrawPoint( VERT(ELT(start)) );

#define RENDER_LINE( v0, v1 ) \
   grDrawLine( VERT(v0), VERT(v1) )

#define RENDER_TRI( v0, v1, v2 )  \
   grDrawTriangle( VERT(v0), VERT(v1), VERT(v2) )

#define RENDER_QUAD( v0, v1, v2, v3 ) \
   do {	\
      GrVertex *_v_[4];	\
      _v_[0] = VERT(v3);\
      _v_[1] = VERT(v0);\
      _v_[2] = VERT(v1);\
      _v_[3] = VERT(v2);\
      grDrawVertexArray(GR_TRIANGLE_FAN, 4, _v_);\
      /*grDrawTriangle( VERT(v0), VERT(v1), VERT(v3) );*/\
      /*grDrawTriangle( VERT(v1), VERT(v2), VERT(v3) );*/\
   } while (0)

#define INIT(x) fxRenderPrimitive( ctx, x )

#undef LOCAL_VARS
#define LOCAL_VARS						\
    fxMesaContext fxMesa = FX_CONTEXT(ctx);			\
    GrVertex *vertptr = fxMesa->verts;		\
    const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts;	\
    (void) elt;

#define RESET_STIPPLE
#define RESET_OCCLUSION
#define PRESERVE_VB_DEFS

/* Elts, no clipping.
 */
#undef ELT
#undef TAG
#define TAG(x) fx_##x##_elts
#define ELT(x) elt[x]
#include "tnl_dd/t_dd_rendertmp.h"

/* Verts, no clipping.
 */
#undef ELT
#undef TAG
#define TAG(x) fx_##x##_verts
#define ELT(x) x
/*#include "tnl_dd/t_dd_rendertmp.h"*/ /* we have fx_render_vb_* now */



/**********************************************************************/
/*                   Render clipped primitives                        */
/**********************************************************************/



static void fxRenderClippedPoly( GLcontext *ctx, const GLuint *elts,
				   GLuint n )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   struct vertex_buffer *VB = &tnl->vb;
   GLuint prim = fxMesa->render_primitive;

   /* Render the new vertices as an unclipped polygon.
    */
   {
      GLuint *tmp = VB->Elts;
      VB->Elts = (GLuint *)elts;
      tnl->Driver.Render.PrimTabElts[GL_POLYGON]( ctx, 0, n,
						  PRIM_BEGIN|PRIM_END );
      VB->Elts = tmp;
   }

   /* Restore the render primitive
    */
   if (prim != GL_POLYGON)
      tnl->Driver.Render.PrimitiveNotify( ctx, prim );
}


static void fxFastRenderClippedPoly( GLcontext *ctx, const GLuint *elts,
				       GLuint n )
{
   int i;
   fxMesaContext fxMesa = FX_CONTEXT( ctx );
   GrVertex *vertptr = fxMesa->verts;
   if (n == 3) {
      grDrawTriangle( VERT(elts[0]), VERT(elts[1]), VERT(elts[2]) );
   } else if (n <= 32) {
      GrVertex *newvptr[32];
      for (i = 0 ; i < n ; i++) {
         newvptr[i] = VERT(elts[i]);
      }
      grDrawVertexArray(GR_TRIANGLE_FAN, n, newvptr);
   } else {
      const GrVertex *start = VERT(elts[0]);
      for (i = 2 ; i < n ; i++) {
         grDrawTriangle( start, VERT(elts[i-1]), VERT(elts[i]) );
      }
   }
}

/**********************************************************************/
/*                    Choose render functions                         */
/**********************************************************************/


#define POINT_FALLBACK (DD_POINT_SMOOTH)
#define LINE_FALLBACK (DD_LINE_STIPPLE)
#define TRI_FALLBACK (DD_TRI_SMOOTH | DD_TRI_STIPPLE)
#define ANY_FALLBACK_FLAGS (POINT_FALLBACK | LINE_FALLBACK | TRI_FALLBACK)
#define ANY_RASTER_FLAGS (DD_FLATSHADE | DD_TRI_LIGHT_TWOSIDE | DD_TRI_OFFSET \
			  | DD_TRI_UNFILLED | DD_TRI_TWOSTENCIL)



void fxDDChooseRenderState(GLcontext *ctx)
{
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GLuint flags = ctx->_TriangleCaps;
   GLuint index = 0;

   if (flags & (ANY_FALLBACK_FLAGS|ANY_RASTER_FLAGS)) {
      if (flags & ANY_RASTER_FLAGS) {
	 if (flags & DD_TRI_TWOSTENCIL)       index |= FX_TWOSTENCIL_BIT;
	 if (flags & DD_TRI_LIGHT_TWOSIDE)    index |= FX_TWOSIDE_BIT;
	 if (flags & DD_TRI_OFFSET)	      index |= FX_OFFSET_BIT;
	 if (flags & DD_TRI_UNFILLED)	      index |= FX_UNFILLED_BIT;
	 if (flags & DD_FLATSHADE)	      index |= FX_FLAT_BIT;
      }

      fxMesa->draw_point = fx_draw_point;
      fxMesa->draw_line = fx_draw_line;
      fxMesa->draw_tri = fx_draw_triangle;

      /* Hook in fallbacks for specific primitives. */
      if (flags & (POINT_FALLBACK|
		   LINE_FALLBACK|
		   TRI_FALLBACK))
      {
         if (fxMesa->verbose) {
            fprintf(stderr, "Voodoo ! fallback (%x), raster (%x)\n",
                            flags & ANY_FALLBACK_FLAGS, flags & ANY_RASTER_FLAGS);
         }

	 if (flags & POINT_FALLBACK)
	    fxMesa->draw_point = fx_fallback_point;

	 if (flags & LINE_FALLBACK)
	    fxMesa->draw_line = fx_fallback_line;

	 if (flags & TRI_FALLBACK)
	    fxMesa->draw_tri = fx_fallback_tri;

	 index |= FX_FALLBACK_BIT;
      }
   }

   tnl->Driver.Render.Points = rast_tab[index].points;
   tnl->Driver.Render.Line = rast_tab[index].line;
   tnl->Driver.Render.ClippedLine = rast_tab[index].line;
   tnl->Driver.Render.Triangle = rast_tab[index].triangle;
   tnl->Driver.Render.Quad = rast_tab[index].quad;

   if (index == 0) {
      tnl->Driver.Render.PrimTabVerts = fx_render_tab_verts;
      tnl->Driver.Render.PrimTabElts = fx_render_tab_elts;
      tnl->Driver.Render.ClippedPolygon = fxFastRenderClippedPoly;
   } else {
      tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
      tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
      tnl->Driver.Render.ClippedPolygon = fxRenderClippedPoly;
   }

   fxMesa->render_index = index;

   /* [dBorca] Hack alert: more a trick than a real plug-in!!! */
   if (flags & (DD_POINT_SIZE | DD_POINT_ATTEN)) {
      /* We need to set the point primitive to go through "rast_tab",
       * to make sure "POINT" calls "fxMesa->draw_point" instead of
       * "grDrawPoint". We can achieve this by using FX_FALLBACK_BIT
       * (not really a total rasterization fallback, so we don't alter
       * "fxMesa->render_index"). If we get here with DD_POINT_SMOOTH,
       * we're done, cos we've already set _tnl_render_tab_{verts|elts}
       * above. Otherwise, the T&L engine can optimize point rendering
       * by using fx_render_tab_{verts|elts} hence the extra work.
       */
      if (flags & DD_POINT_SMOOTH) {
         fxMesa->draw_point = fx_draw_point_wide_aa;
      } else {
         fxMesa->draw_point = fx_draw_point_wide;
         fx_render_tab_verts[0] = fx_render_pw_verts;
         fx_render_tab_elts[0] = fx_render_pw_elts;
      }
      tnl->Driver.Render.Points = rast_tab[index|FX_FALLBACK_BIT].points;
   } else {
      fx_render_tab_verts[0] = fx_render_vb_points;
      fx_render_tab_elts[0] = fx_render_points_elts;
   }
}


/**********************************************************************/
/*                Runtime render state and callbacks                  */
/**********************************************************************/

static void fxRunPipeline( GLcontext *ctx )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GLuint new_gl_state = fxMesa->new_gl_state;

   if (TDFX_DEBUG & VERBOSE_PIPELINE) {
      fprintf(stderr, "fxRunPipeline()\n");
   }

#if 0
   /* Recalculate fog table on projection matrix changes.  This used to
    * be triggered by the NearFar callback.
    */
   if (new_gl_state & _NEW_PROJECTION)
      fxMesa->new_state |= FX_NEW_FOG;
#endif

   if (new_gl_state & _FX_NEW_IS_IN_HARDWARE)
      fxCheckIsInHardware(ctx);

   if (fxMesa->new_state)
      fxSetupFXUnits(ctx);

   if (!fxMesa->fallback) {
      if (new_gl_state & _FX_NEW_RENDERSTATE)
         fxDDChooseRenderState(ctx);

      if (new_gl_state & _FX_NEW_SETUP_FUNCTION)
         fxChooseVertexState(ctx);
   }

   if (new_gl_state & _NEW_TEXTURE) {
      struct gl_texture_unit *t0 = &ctx->Texture.Unit[fxMesa->tmu_source[0]];
      struct gl_texture_unit *t1 = &ctx->Texture.Unit[fxMesa->tmu_source[1]];

      if (t0->_Current && FX_TEXTURE_DATA(t0)) {
         fxMesa->s0scale = FX_TEXTURE_DATA(t0)->sScale;
         fxMesa->t0scale = FX_TEXTURE_DATA(t0)->tScale;
         fxMesa->inv_s0scale = 1.0F / fxMesa->s0scale;
         fxMesa->inv_t0scale = 1.0F / fxMesa->t0scale;
      }

      if (t1->_Current && FX_TEXTURE_DATA(t1)) {
         fxMesa->s1scale = FX_TEXTURE_DATA(t1)->sScale;
         fxMesa->t1scale = FX_TEXTURE_DATA(t1)->tScale;
         fxMesa->inv_s1scale = 1.0F / fxMesa->s1scale;
         fxMesa->inv_t1scale = 1.0F / fxMesa->t1scale;
      }
   }

   fxMesa->new_gl_state = 0;

   _tnl_run_pipeline( ctx );
}



/* Always called between RenderStart and RenderFinish --> We already
 * hold the lock.
 */
static void fxRasterPrimitive( GLcontext *ctx, GLenum prim )
{
   fxMesaContext fxMesa = FX_CONTEXT( ctx );

   fxMesa->raster_primitive = prim;

   fxSetupCull(ctx);
}



/* Determine the rasterized primitive when not drawing unfilled
 * polygons.
 */
static void fxRenderPrimitive( GLcontext *ctx, GLenum prim )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   GLuint rprim = reduced_prim[prim];

   fxMesa->render_primitive = prim;

   if (rprim == GL_TRIANGLES && (ctx->_TriangleCaps & DD_TRI_UNFILLED))
      return;

   if (fxMesa->raster_primitive != rprim) {
      fxRasterPrimitive( ctx, rprim );
   }
}

static void fxRenderFinish( GLcontext *ctx )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);

   if (fxMesa->render_index & FX_FALLBACK_BIT)
      _swrast_flush( ctx );
}



/**********************************************************************/
/*               Manage total rasterization fallbacks                 */
/**********************************************************************/

static char *fallbackStrings[] = {
   "3D/Rect/Cube Texture map",
   "glDrawBuffer(GL_FRONT_AND_BACK)",
   "Separate specular color",
   "glEnable/Disable(GL_STENCIL_TEST)",
   "glRenderMode(selection or feedback)",
   "glLogicOp()",
   "Texture env mode",
   "Texture border",
   "glColorMask",
   "blend mode",
   "multitex"
};


static char *getFallbackString(GLuint bit)
{
   int i = 0;
   while (bit > 1) {
      i++;
      bit >>= 1;
   }
   return fallbackStrings[i];
}


void fxCheckIsInHardware( GLcontext *ctx )
{
   fxMesaContext fxMesa = FX_CONTEXT(ctx);
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   GLuint oldfallback = fxMesa->fallback;
   GLuint newfallback = fxMesa->fallback = fx_check_IsInHardware( ctx );

   if (newfallback) {
      if (oldfallback == 0) {
         if (fxMesa->verbose) {
            fprintf(stderr, "Voodoo ! enter SW 0x%08x %s\n", newfallback, getFallbackString(newfallback));
         }
	 _swsetup_Wakeup( ctx );
      }
   }
   else {
      if (oldfallback) {
	 _swrast_flush( ctx );
	 tnl->Driver.Render.Start = fxCheckTexSizes;
	 tnl->Driver.Render.Finish = fxRenderFinish;
	 tnl->Driver.Render.PrimitiveNotify = fxRenderPrimitive;
	 tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
	 tnl->Driver.Render.ClippedLine = _tnl_RenderClippedLine;
	 tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
	 tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
	 tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple;
	 tnl->Driver.Render.BuildVertices = fxBuildVertices;
	 fxChooseVertexState(ctx);
	 fxDDChooseRenderState(ctx);
         if (fxMesa->verbose) {
            fprintf(stderr, "Voodoo ! leave SW 0x%08x %s\n", oldfallback, getFallbackString(oldfallback));
         }
      }
      tnl->Driver.Render.Multipass = NULL;
      if (HAVE_SPEC && NEED_SECONDARY_COLOR(ctx)) {
         tnl->Driver.Render.Multipass = fxMultipass_ColorSum;
         /* obey stencil, but do not change it */
         fxMesa->multipass = GL_TRUE;
         if (fxMesa->unitsState.stencilEnabled) {
            fxMesa->new_state |= FX_NEW_STENCIL;
         }
      }
   }
}

void fxDDInitTriFuncs( GLcontext *ctx )
{
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   static int firsttime = 1;

   if (firsttime) {
      init_rast_tab();
      firsttime = 0;
   }

   tnl->Driver.RunPipeline = fxRunPipeline;
   tnl->Driver.Render.Start = fxCheckTexSizes;
   tnl->Driver.Render.Finish = fxRenderFinish;
   tnl->Driver.Render.PrimitiveNotify = fxRenderPrimitive;
   tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
   tnl->Driver.Render.ClippedLine = _tnl_RenderClippedLine;
   tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
   tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
   tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple;
   tnl->Driver.Render.BuildVertices = fxBuildVertices;
   tnl->Driver.Render.Multipass = NULL;

   (void) fx_print_vertex;
}


/* [dBorca] Hack alert:
 * doesn't work with blending.
 */
static GLboolean
fxMultipass_ColorSum (GLcontext *ctx, GLuint pass)
{
 fxMesaContext fxMesa = FX_CONTEXT(ctx);
 tfxUnitsState *us = &fxMesa->unitsState;

 static int t0 = 0;
 static int t1 = 0;

 switch (pass) {
        case 1: /* first pass: the TEXTURED triangles are drawn */
             /* set stencil's real values */
             fxMesa->multipass = GL_FALSE;
             if (us->stencilEnabled) {
                fxSetupStencil(ctx);
             }
             /* save per-pass data */
             fxMesa->restoreUnitsState = *us;
             /* turn off texturing */
             t0 = ctx->Texture.Unit[0]._ReallyEnabled;
             t1 = ctx->Texture.Unit[1]._ReallyEnabled;
             ctx->Texture.Unit[0]._ReallyEnabled = 0;
             ctx->Texture.Unit[1]._ReallyEnabled = 0;
             /* SUM the colors */
             fxDDBlendEquationSeparate(ctx, GL_FUNC_ADD, GL_FUNC_ADD);
             fxDDBlendFuncSeparate(ctx, GL_ONE, GL_ONE, GL_ZERO, GL_ONE);
             fxDDEnable(ctx, GL_BLEND, GL_TRUE);
             /* make sure we draw only where we want to */
             if (us->depthTestEnabled) {
                switch (us->depthTestFunc) {
                   default:
                      fxDDDepthFunc(ctx, GL_EQUAL);
                   case GL_NEVER:
                   case GL_ALWAYS:
                      ;
                }
                fxDDDepthMask(ctx, GL_FALSE);
             }
             /* switch to secondary colors */
#if FX_PACKEDCOLOR
             grVertexLayout(GR_PARAM_PARGB, GR_VERTEX_PSPEC_OFFSET << 2, GR_PARAM_ENABLE);
#else  /* !FX_PACKEDCOLOR */
             grVertexLayout(GR_PARAM_RGB, GR_VERTEX_SPEC_OFFSET << 2, GR_PARAM_ENABLE);
#endif /* !FX_PACKEDCOLOR */
             /* don't advertise new state */
             fxMesa->new_state = 0;
             break;
        case 2: /* 2nd pass (last): the secondary color is summed over texture */
             /* restore original state */
             *us = fxMesa->restoreUnitsState;
             /* restore texturing */
             ctx->Texture.Unit[0]._ReallyEnabled = t0;
             ctx->Texture.Unit[1]._ReallyEnabled = t1;
             /* revert to primary colors */
#if FX_PACKEDCOLOR
             grVertexLayout(GR_PARAM_PARGB, GR_VERTEX_PARGB_OFFSET << 2, GR_PARAM_ENABLE);
#else  /* !FX_PACKEDCOLOR */
             grVertexLayout(GR_PARAM_RGB, GR_VERTEX_RGB_OFFSET << 2, GR_PARAM_ENABLE);
#endif /* !FX_PACKEDCOLOR */
             break;
        default:
             assert(0); /* NOTREACHED */
 }

 /* update HW state */
 fxSetupBlend(ctx);
 fxSetupDepthTest(ctx);
 fxSetupTexture(ctx);

 return (pass == 1);
}


#else


/*
 * Need this to provide at least one external definition.
 */

extern int gl_fx_dummy_function_tris(void);
int
gl_fx_dummy_function_tris(void)
{
   return 0;
}

#endif /* FX */
