/* Authors:
* Keith Whitwell <keith@tungstengraphics.com>
+ * Daniel Borca <dborca@users.sourceforge.net>
*/
#include "glheader.h"
#ifdef FX
+#include "imports.h"
#include "mtypes.h"
#include "macros.h"
#include "colormac.h"
-
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
#include "tnl/t_context.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.
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 *
***********************************************************************/
fxMesa->draw_tri( fxMesa, a, b, d ); \
fxMesa->draw_tri( fxMesa, b, c, d ); \
} else { \
- grDrawTriangle( a, b, d ); \
- grDrawTriangle( b, c, d ); \
+ 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)
* Fallback to swrast for basic primitives *
***********************************************************************/
-/* Build an SWvertex from a hardware vertex.
+/* 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.
+ * primitives.
*/
-static void
+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.0 / src->oow;
+ 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.0;
+ dst->texcoord[ts0][3] = 1.0F;
if (fxMesa->SetupIndex & SETUP_TMU1) {
dst->texcoord[ts1][0] = fxMesa->inv_s1scale * src->tmuvtx[1].sow * 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.0;
+ dst->texcoord[ts1][3] = 1.0F;
}
- dst->pointSize = ctx->Point._Size;
+ dst->pointSize = src->psize;
}
-static void
-fx_fallback_tri( fxMesaContext fxMesa,
- GrVertex *v0,
- GrVertex *v1,
+static void
+fx_fallback_tri( fxMesaContext fxMesa,
+ GrVertex *v0,
+ GrVertex *v1,
GrVertex *v2 )
{
GLcontext *ctx = fxMesa->glCtx;
}
-static void
+static void
fx_fallback_line( fxMesaContext fxMesa,
GrVertex *v0,
GrVertex *v1 )
}
-static void
-fx_fallback_point( fxMesaContext fxMesa,
+static void
+fx_fallback_point( fxMesaContext fxMesa,
GrVertex *v0 )
{
GLcontext *ctx = fxMesa->glCtx;
static void fx_print_vertex( GLcontext *ctx, const GrVertex *v )
{
- fprintf(stderr, "%s:\n", __FUNCTION__);
+ 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");
}
* rendering. These functions are only used when mixed-mode rendering
* is occurring.
*/
-static void fx_draw_quad( fxMesaContext fxMesa,
- GrVertex *v0,
- GrVertex *v1,
- GrVertex *v2,
- GrVertex *v3 )
-{
- BEGIN_CLIP_LOOP();
- QUAD( v0, v1, v2, v3 );
- END_CLIP_LOOP();
-}
-
static void fx_draw_triangle( fxMesaContext fxMesa,
GrVertex *v0,
GrVertex *v1,
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_OFFSET_BIT 0x2
#define FX_TWOSIDE_BIT 0x4
#define FX_FLAT_BIT 0x8
-#define FX_FALLBACK_BIT 0x10
-#define FX_MAX_TRIFUNC 0x20
+#define FX_TWOSTENCIL_BIT 0x10
+#define FX_FALLBACK_BIT 0x20
+#define FX_MAX_TRIFUNC 0x40
static struct {
- points_func points;
- line_func line;
- triangle_func triangle;
- quad_func quad;
+ 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_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_FULL_QUAD 1
#define HAVE_RGBA 1
-#define HAVE_SPEC 0
+#define HAVE_SPEC 1
#define HAVE_HW_FLATSHADE 0
#define HAVE_BACK_COLORS 0
#define VERTEX GrVertex
#define VERT_X(_v) _v->x
#define VERT_Y(_v) _v->y
#define VERT_Z(_v) _v->ooz
-#define AREA_IS_CCW( a ) (a < 0)
+#define AREA_IS_CCW( a ) IS_NEGATIVE( a )
#define GET_VERTEX(e) (fxMesa->verts + e)
-#define VERT_SET_RGBA( dst, f ) \
+
+#if FX_PACKEDCOLOR
+#define VERT_SET_RGBA( dst, f ) \
do { \
- dst->pargb[2] = f[0]; \
- dst->pargb[1] = f[1]; \
- dst->pargb[0] = f[2]; \
- dst->pargb[3] = f[3]; \
+ 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 ) \
#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 LOCAL_VARS(n) \
- fxMesaContext fxMesa = FX_CONTEXT(ctx); \
- GLubyte color[n][4]; \
- (void) color;
+#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 != x) \
- fxRasterPrimitive( ctx, x )
+#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 "../common/t_dd_unfilled.h"
+#include "tnl_dd/t_dd_unfilled.h"
#undef IND
/***********************************************************************
#define IND (0)
#define TAG(x) x
-#include "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_OFFSET_BIT)
#define TAG(x) x##_offset
-#include "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_TWOSIDE_BIT)
#define TAG(x) x##_twoside
-#include "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_TWOSIDE_BIT|FX_OFFSET_BIT)
#define TAG(x) x##_twoside_offset
-#include "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_UNFILLED_BIT)
#define TAG(x) x##_unfilled
-#include "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_OFFSET_BIT|FX_UNFILLED_BIT)
#define TAG(x) x##_offset_unfilled
-#include "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_TWOSIDE_BIT|FX_UNFILLED_BIT)
#define TAG(x) x##_twoside_unfilled
-#include "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_FALLBACK_BIT)
#define TAG(x) x##_fallback
-#include "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_OFFSET_BIT|FX_FALLBACK_BIT)
#define TAG(x) x##_offset_fallback
-#include "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_TWOSIDE_BIT|FX_FALLBACK_BIT)
#define TAG(x) x##_twoside_fallback
-#include "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_UNFILLED_BIT|FX_FALLBACK_BIT)
#define TAG(x) x##_unfilled_fallback
-#include "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_OFFSET_BIT|FX_FLAT_BIT)
#define TAG(x) x##_offset_flat
-#include "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_TWOSIDE_BIT|FX_FLAT_BIT)
#define TAG(x) x##_twoside_flat
-#include "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_UNFILLED_BIT|FX_FLAT_BIT)
#define TAG(x) x##_unfilled_flat
-#include "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#include "tnl_dd/t_dd_tritmp.h"
#define IND (FX_FALLBACK_BIT|FX_FLAT_BIT)
#define TAG(x) x##_fallback_flat
-#include "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#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 "../common/t_dd_tritmp.h"
+#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_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 */
}
/* 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,
fprintf(stderr, "fx_render_vb_points\n");
}
- fxRenderPrimitive(ctx, GL_POINTS);
+ INIT(GL_POINTS);
/* Adjust point coords */
for (i = start; i < count; i++) {
fprintf(stderr, "fx_render_vb_line_strip\n");
}
- fxRenderPrimitive(ctx, GL_LINE_STRIP);
+ INIT(GL_LINE_STRIP);
/* adjust line coords */
for (i = start; i < count; i++) {
fprintf(stderr, "fx_render_vb_line_loop\n");
}
- fxRenderPrimitive(ctx, GL_LINE_LOOP);
+ INIT(GL_LINE_LOOP);
if (!(flags & PRIM_BEGIN)) {
j++;
grDrawVertexArrayContiguous( GR_LINE_STRIP, count-j,
fxVB + j, sizeof(GrVertex));
- if (flags & PRIM_END)
+ if (flags & PRIM_END)
grDrawLine( fxVB + (count - 1),
fxVB + start );
fprintf(stderr, "fx_render_vb_lines\n");
}
- fxRenderPrimitive(ctx, GL_LINES);
+ INIT(GL_LINES);
/* adjust line coords */
for (i = start; i < count; i++) {
{
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");
}
- fxRenderPrimitive(ctx, GL_TRIANGLES);
+ INIT(GL_TRIANGLES);
-#if 0
- /* [dBorca]
- * apparently, this causes troubles with some programs (GLExcess);
- * might be a bug in Glide... However, "grDrawVertexArrayContiguous"
- * eventually calls "grDrawTriangle" for GR_TRIANGLES, so we're better
- * off doing it by hand...
- */
- grDrawVertexArrayContiguous( GR_TRIANGLES, count-start,
- fxVB + start, sizeof(GrVertex));
-#else
- {
- GLuint j;
- for (j=start+2; j<count; j+=3) {
- grDrawTriangle(fxVB + (j-2), fxVB + (j-1), fxVB + j);
- }
+ for (j=start+2; j<count; j+=3) {
+ grDrawTriangle(fxVB + (j-2), fxVB + (j-1), fxVB + j);
}
-#endif
}
{
fxMesaContext fxMesa = FX_CONTEXT(ctx);
GrVertex *fxVB = fxMesa->verts;
- int mode;
(void) flags;
if (TDFX_DEBUG & VERBOSE_VARRAY) {
fprintf(stderr, "fx_render_vb_tri_strip\n");
}
- fxRenderPrimitive(ctx, GL_TRIANGLE_STRIP);
+ INIT(GL_TRIANGLE_STRIP);
- if (flags & PRIM_PARITY)
- mode = GR_TRIANGLE_STRIP_CONTINUE;
- else
- mode = GR_TRIANGLE_STRIP;
+ /* no GR_TRIANGLE_STRIP_CONTINUE?!? */
- grDrawVertexArrayContiguous( mode, count-start,
+ grDrawVertexArrayContiguous( GR_TRIANGLE_STRIP, count-start,
fxVB + start, sizeof(GrVertex));
}
fprintf(stderr, "fx_render_vb_tri_fan\n");
}
- fxRenderPrimitive(ctx, GL_TRIANGLE_FAN);
+ INIT(GL_TRIANGLE_FAN);
grDrawVertexArrayContiguous( GR_TRIANGLE_FAN, count-start,
fxVB + start, sizeof(GrVertex) );
fprintf(stderr, "fx_render_vb_quads\n");
}
- fxRenderPrimitive(ctx, GL_QUADS);
+ INIT(GL_QUADS);
- for (i = start ; i < count-3 ; i += 4 ) {
+ for (i = start + 3 ; i < count ; i += 4 ) {
#define VERT(x) (fxVB + (x))
- grDrawTriangle( VERT(i), VERT(i+1), VERT(i+3) );
- grDrawTriangle( VERT(i+1), VERT(i+2), VERT(i+3) );
+ 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
}
}
fprintf(stderr, "fx_render_vb_quad_strip\n");
}
- fxRenderPrimitive(ctx, GL_QUAD_STRIP);
+ INIT(GL_QUAD_STRIP);
count -= (count-start)&1;
fprintf(stderr, "fx_render_vb_poly\n");
}
- fxRenderPrimitive(ctx, GL_POLYGON);
+ INIT(GL_POLYGON);
grDrawVertexArrayContiguous( GR_POLYGON, count-start,
fxVB + start, sizeof(GrVertex));
static void (*fx_render_tab_verts[GL_POLYGON+2])(GLcontext *,
GLuint,
GLuint,
- GLuint) =
+ GLuint) =
{
fx_render_vb_points,
fx_render_vb_lines,
fx_render_vb_poly,
fx_render_vb_noop,
};
+#undef INIT
/**********************************************************************/
grDrawTriangle( VERT(v0), VERT(v1), VERT(v2) )
#define RENDER_QUAD( v0, v1, v2, v3 ) \
- fx_draw_quad( fxMesa, VERT(v0), VERT(v1), VERT(v2), VERT(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 )
const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \
(void) elt;
-#define RESET_STIPPLE
-#define RESET_OCCLUSION
+#define RESET_STIPPLE
+#define RESET_OCCLUSION
#define PRESERVE_VB_DEFS
/* Elts, no clipping.
#undef TAG
#define TAG(x) fx_##x##_elts
#define ELT(x) elt[x]
-#include "../common/t_dd_rendertmp.h"
+#include "tnl_dd/t_dd_rendertmp.h"
/* Verts, no clipping.
*/
#undef TAG
#define TAG(x) fx_##x##_verts
#define ELT(x) x
-/*#include "../common/t_dd_rendertmp.h"*/ /* we have fx_render_vb_* now */
+/*#include "tnl_dd/t_dd_rendertmp.h"*/ /* we have fx_render_vb_* now */
-static void fxRenderClippedPoly( GLcontext *ctx, const GLuint *elts,
+static void fxRenderClippedPoly( GLcontext *ctx, const GLuint *elts,
GLuint n )
{
fxMesaContext fxMesa = FX_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb;
GLuint prim = fxMesa->render_primitive;
- /* Render the new vertices as an unclipped polygon.
+ /* 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,
+ tnl->Driver.Render.PrimTabElts[GL_POLYGON]( ctx, 0, n,
PRIM_BEGIN|PRIM_END );
VB->Elts = tmp;
}
}
-static void fxFastRenderClippedPoly( GLcontext *ctx, const GLuint *elts,
+static void fxFastRenderClippedPoly( GLcontext *ctx, const GLuint *elts,
GLuint n )
{
+ int i;
fxMesaContext fxMesa = FX_CONTEXT( ctx );
GrVertex *vertptr = fxMesa->verts;
- const GrVertex *start = VERT(elts[0]);
- int i;
- for (i = 2 ; i < n ; i++) {
- grDrawTriangle( start, VERT(elts[i-1]), VERT(elts[i]) );
+ 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]) );
+ }
}
}
#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_UNFILLED | DD_TRI_TWOSTENCIL)
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;
fxMesa->draw_line = fx_draw_line;
fxMesa->draw_tri = fx_draw_triangle;
- /* Hook in fallbacks for specific primitives.
- * [dBorca] Hack alert:
- * If we're in FSAA mode, we always do anti-aliased primitives.
- */
+ /* Hook in fallbacks for specific primitives. */
if (flags & (POINT_FALLBACK|
LINE_FALLBACK|
TRI_FALLBACK))
}
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;
+ }
}
*/
if (new_gl_state & _NEW_PROJECTION)
fxMesa->new_state |= FX_NEW_FOG;
- /* [dBorca] Hack alert:
- * the above _NEW_PROJECTION is not included in the test below,
- * so we may end up with fxMesa->new_state still dirty by the end
- * of the routine. The fact is, we don't have NearFar callback
- * anymore. We could use fxDDDepthRange instead, but it seems
- * fog needs to be updated only by a fog-basis.
- * Implementing fxDDDepthRange correctly is another story:
- * that, together with a presumable fxDDViewport function would set
- * fxMesa->SetupNewInputs |= VERT_BIT_CLIP;
- * which might be useful in fxBuildVertices...
- */
#endif
- if (new_gl_state & (_FX_NEW_IS_IN_HARDWARE |
- _FX_NEW_RENDERSTATE |
- _FX_NEW_SETUP_FUNCTION |
- _NEW_TEXTURE)) {
+ if (new_gl_state & _FX_NEW_IS_IN_HARDWARE)
+ fxCheckIsInHardware(ctx);
- if (new_gl_state & _FX_NEW_IS_IN_HARDWARE)
- fxCheckIsInHardware(ctx);
+ if (fxMesa->new_state)
+ fxSetupFXUnits(ctx);
- if (fxMesa->new_state)
- fxSetupFXUnits(ctx);
+ if (!fxMesa->fallback) {
+ if (new_gl_state & _FX_NEW_RENDERSTATE)
+ fxDDChooseRenderState(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 & _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 (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 && t0->_Current && FX_TEXTURE_DATA(t0)) {
- fxMesa->s0scale = FX_TEXTURE_DATA(t0)->sScale;
- fxMesa->t0scale = FX_TEXTURE_DATA(t0)->tScale;
- fxMesa->inv_s0scale = 1.0 / fxMesa->s0scale;
- fxMesa->inv_t0scale = 1.0 / fxMesa->t0scale;
- }
-
- if (t1 && t1->_Current && FX_TEXTURE_DATA(t1)) {
- fxMesa->s1scale = FX_TEXTURE_DATA(t1)->sScale;
- fxMesa->t1scale = FX_TEXTURE_DATA(t1)->tScale;
- fxMesa->inv_s1scale = 1.0 / fxMesa->s1scale;
- fxMesa->inv_t1scale = 1.0 / fxMesa->t1scale;
- }
+ 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 );
}
-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
-};
-
-
/* Always called between RenderStart and RenderFinish --> We already
* hold the lock.
-/* Determine the rasterized primitive when not drawing unfilled
+/* Determine the rasterized primitive when not drawing unfilled
* polygons.
*/
static void fxRenderPrimitive( GLcontext *ctx, GLenum prim )
if (rprim == GL_TRIANGLES && (ctx->_TriangleCaps & DD_TRI_UNFILLED))
return;
-
+
if (fxMesa->raster_primitive != rprim) {
fxRasterPrimitive( ctx, rprim );
}
/**********************************************************************/
static char *fallbackStrings[] = {
- "1D/3D Texture map",
+ "3D/Rect/Cube Texture map",
"glDrawBuffer(GL_FRONT_AND_BACK)",
"Separate specular color",
"glEnable/Disable(GL_STENCIL_TEST)",
"Texture border",
"glColorMask",
"blend mode",
- "line stipple"
+ "multitex"
};
tnl->Driver.Render.Start = fxCheckTexSizes;
tnl->Driver.Render.Finish = fxRenderFinish;
tnl->Driver.Render.PrimitiveNotify = fxRenderPrimitive;
- tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
+ 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 = 0;
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;
+ }
+ }
}
}
tnl->Driver.Render.Start = fxCheckTexSizes;
tnl->Driver.Render.Finish = fxRenderFinish;
tnl->Driver.Render.PrimitiveNotify = fxRenderPrimitive;
- tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
+ 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 = 0;
-
+ 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