* dma buffers. Use strip/fan hardware acceleration where possible.
*
*/
-#include "glheader.h"
-#include "context.h"
-#include "macros.h"
-#include "mtypes.h"
+#include "main/glheader.h"
+#include "main/context.h"
+#include "main/macros.h"
+#include "main/mtypes.h"
+
+#include "math/m_xform.h"
#include "tnl/t_context.h"
#include "via_context.h"
#include "via_tris.h"
-#include "via_state.h"
-#include "via_vb.h"
#include "via_ioctl.h"
/*
#define HAVE_LINE_LOOP 1
#define HAVE_TRIANGLES 1
#define HAVE_TRI_STRIPS 1
-#define HAVE_TRI_STRIP_1 0 /* has it, template can't use it yet */
+#define HAVE_TRI_STRIP_1 0
#define HAVE_TRI_FANS 1
#define HAVE_POLYGONS 1
#define HAVE_QUADS 0
#define HAVE_ELTS 0
-static const GLenum reducedPrim[GL_POLYGON + 1] = {
- GL_POINTS,
- GL_LINES,
- GL_LINES,
- GL_LINES,
- GL_TRIANGLES,
- GL_TRIANGLES,
- GL_TRIANGLES,
- GL_TRIANGLES,
- GL_TRIANGLES,
- GL_TRIANGLES
-};
-
-/* Fallback to normal rendering.
- */
-static void VERT_FALLBACK(GLcontext *ctx,
- GLuint start,
- GLuint count,
- GLuint flags)
-{
- TNLcontext *tnl = TNL_CONTEXT(ctx);
-#ifdef DEBUG
- if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
-#endif
- fprintf(stderr, "VERT_FALLBACK\n");
- tnl->Driver.Render.PrimitiveNotify(ctx, flags & PRIM_MODE_MASK);
- tnl->Driver.Render.BuildVertices(ctx, start, count, ~0);
- tnl->Driver.Render.PrimTabVerts[flags & PRIM_MODE_MASK](ctx, start,
- count, flags);
- VIA_CONTEXT(ctx)->setupNewInputs = VERT_BIT_CLIP;
-#ifdef DEBUG
- if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
-#endif
-}
-
-
-#define LOCAL_VARS viaContextPtr vmesa = VIA_CONTEXT(ctx)
-/*
-#define INIT(prim) \
- do { \
- VIA_STATECHANGE(vmesa, 0); \
- viaRasterPrimitive(ctx, reducedPrim[prim], prim); \
- } while (0)
-*/
-#define INIT(prim) \
- do { \
- viaRasterPrimitive(ctx, reducedPrim[prim], prim); \
- } while (0)
-#define NEW_PRIMITIVE() VIA_STATECHANGE(vmesa, 0)
-#define NEW_BUFFER() VIA_FIREVERTICES(vmesa)
+#define LOCAL_VARS struct via_context *vmesa = VIA_CONTEXT(ctx)
+#define INIT(prim) do { \
+ viaRasterPrimitive(ctx, prim, prim); \
+} while (0)
#define GET_CURRENT_VB_MAX_VERTS() \
- (((int)vmesa->dmaHigh - (int)vmesa->dmaLow) / (vmesa->vertexSize * 4))
+ ((VIA_DMA_BUF_SZ - (512 + (int)vmesa->dmaLow)) / (vmesa->vertexSize * 4))
#define GET_SUBSEQUENT_VB_MAX_VERTS() \
- (VIA_DMA_BUF_SZ - 4) / (vmesa->vertexSize * 4)
+ (VIA_DMA_BUF_SZ - 512) / (vmesa->vertexSize * 4)
+#define ALLOC_VERTS( nr ) \
+ viaExtendPrimitive( vmesa, (nr) * vmesa->vertexSize * 4)
-#define EMIT_VERTS(ctx, j, nr) \
- via_emit_contiguous_verts(ctx, j, (j) + (nr))
+#define EMIT_VERTS(ctx, j, nr, buf) \
+ _tnl_emit_vertices_to_buffer(ctx, j, (j)+(nr), buf )
-#define FINISH \
- do { \
- vmesa->primitiveRendered = GL_TRUE; \
- viaRasterPrimitiveFinish(ctx); \
- } while (0)
-
+#define FLUSH() VIA_FINISH_PRIM( vmesa )
#define TAG(x) via_fast##x
-#include "via_dmatmp.h"
+#include "tnl_dd/t_dd_dmatmp.h"
#undef TAG
#undef LOCAL_VARS
#undef INIT
/**********************************************************************/
/* Fast Render pipeline stage */
/**********************************************************************/
-static GLboolean via_run_fastrender(GLcontext *ctx,
+static GLboolean via_run_fastrender(struct gl_context *ctx,
struct tnl_pipeline_stage *stage)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb;
- GLuint i, length, flags = 0;
+ GLuint i;
- /* Don't handle clipping or indexed vertices.
- */
-#ifdef PERFORMANCE_MEASURE
- if (VIA_PERFORMANCE) P_M;
-#endif
+
+ tnl->Driver.Render.Start(ctx);
- if (VB->ClipOrMask || vmesa->renderIndex != 0 || VB->Elts) {
-#ifdef DEBUG
- if (VIA_DEBUG) {
- fprintf(stderr, "slow path\n");
- fprintf(stderr, "ClipOrMask = %08x\n", VB->ClipOrMask);
- fprintf(stderr, "renderIndex = %08x\n", vmesa->renderIndex);
- fprintf(stderr, "Elts = %08x\n", (GLuint)VB->Elts);
- }
-#endif
+ if (VB->ClipOrMask ||
+ vmesa->renderIndex != 0 ||
+ !via_fastvalidate_render( ctx, VB )) {
+ tnl->Driver.Render.Finish(ctx);
return GL_TRUE;
}
-#ifdef DEBUG
- if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
-#endif
- vmesa->setupNewInputs = VERT_BIT_CLIP;
- vmesa->primitiveRendered = GL_TRUE;
- tnl->Driver.Render.Start(ctx);
-
+ tnl->clipspace.new_inputs |= VERT_BIT_POS;
+
for (i = 0; i < VB->PrimitiveCount; ++i) {
- GLuint mode = VB->Primitive[i].mode;
+ GLuint mode = _tnl_translate_prim(&VB->Primitive[i]);
GLuint start = VB->Primitive[i].start;
GLuint length = VB->Primitive[i].count;
if (length)
}
tnl->Driver.Render.Finish(ctx);
-
- /*=* DBG - viewperf7.0 : fix command buffer overflow *=*/
- if (vmesa->dmaLow > (vmesa->dma[0].size / 2))
- viaFlushPrims(vmesa);
-#ifdef DEBUG
- if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
-#endif
- return GL_FALSE; /* finished the pipe */
-}
-
-
-static void via_check_fastrender(GLcontext *ctx, struct tnl_pipeline_stage *stage)
-{
- GLuint inputs = VERT_BIT_CLIP | VERT_BIT_COLOR0;
-
- if (ctx->RenderMode == GL_RENDER) {
- if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)
- inputs |= VERT_BIT_COLOR1;
-
- if (ctx->Texture.Unit[0]._ReallyEnabled)
- inputs |= VERT_BIT_TEX0;
- if (ctx->Texture.Unit[1]._ReallyEnabled)
- inputs |= VERT_BIT_TEX1;
-
- if (ctx->Fog.Enabled)
- inputs |= VERT_BIT_FOG;
- }
-
- stage->inputs = inputs;
-}
-
-
-static void fastdtr(struct tnl_pipeline_stage *stage)
-{
- (void)stage;
+ return GL_FALSE; /* finished the pipe */
}
-
const struct tnl_pipeline_stage _via_fastrender_stage =
{
"via fast render",
- (_DD_NEW_SEPARATE_SPECULAR |
- _NEW_TEXTURE|
- _NEW_FOG|
- _NEW_RENDERMODE), /* re-check (new inputs) */
- 0, /* re-run (always runs) */
- GL_TRUE, /* active */
- 0, 0, /* inputs (set in check_render), outputs */
- 0, 0, /* changed_inputs, private */
- fastdtr, /* destructor */
- via_check_fastrender, /* check - initially set to alloc data */
+ NULL,
+ NULL,
+ NULL,
+ NULL,
via_run_fastrender /* run */
};
-/*
- * Render whole vertex buffers, including projection of vertices from
- * clip space and clipping of primitives.
- *
- * This file makes calls to project vertices and to the point, line
- * and triangle rasterizers via the function pointers:
- *
- * context->Driver.Render.*
- *
- */
-
-
-/**********************************************************************/
-/* Clip single primitives */
-/**********************************************************************/
-#undef DIFFERENT_SIGNS
-#if defined(USE_IEEE)
-#define NEGATIVE(x) (GET_FLOAT_BITS(x) & (1 << 31))
-#define DIFFERENT_SIGNS(x, y) ((GET_FLOAT_BITS(x) ^ GET_FLOAT_BITS(y)) & (1 << 31))
-#else
-#define NEGATIVE(x) (x < 0)
-#define DIFFERENT_SIGNS(x,y) (x * y <= 0 && x - y != 0)
-/* Could just use (x*y<0) except for the flatshading requirements.
- * Maybe there's a better way?
- */
-#endif
-
-#define W(i) coord[i][3]
-#define Z(i) coord[i][2]
-#define Y(i) coord[i][1]
-#define X(i) coord[i][0]
-#define SIZE 4
-#define TAG(x) x##_4
-#include "via_vb_cliptmp.h"
-
-
-/**********************************************************************/
-/* Clip and render whole begin/end objects */
-/**********************************************************************/
-#define NEED_EDGEFLAG_SETUP (ctx->_TriangleCaps & DD_TRI_UNFILLED)
-#define EDGEFLAG_GET(idx) VB->EdgeFlag[idx]
-#define EDGEFLAG_SET(idx, val) VB->EdgeFlag[idx] = val
-
-
-/* Vertices, with the possibility of clipping.
- */
-#define RENDER_POINTS(start, count) \
- tnl->Driver.Render.Points(ctx, start, count)
-
-#define RENDER_LINE(v1, v2) \
- do { \
- GLubyte c1 = mask[v1], c2 = mask[v2]; \
- GLubyte ormask = c1 | c2; \
- if (!ormask) \
- LineFunc(ctx, v1, v2); \
- else if (!(c1 & c2 & 0x3f)) \
- clip_line_4(ctx, v1, v2, ormask); \
- } while (0)
-
-#define RENDER_TRI(v1, v2, v3) \
- if (VIA_DEBUG) fprintf(stderr, "RENDER_TRI - clip\n"); \
- do { \
- GLubyte c1 = mask[v1], c2 = mask[v2], c3 = mask[v3]; \
- GLubyte ormask = c1 | c2 | c3; \
- if (!ormask) \
- TriangleFunc(ctx, v1, v2, v3); \
- else if (!(c1 & c2 & c3 & 0x3f)) \
- clip_tri_4(ctx, v1, v2, v3, ormask); \
- } while (0)
-
-#define RENDER_QUAD(v1, v2, v3, v4) \
- do { \
- GLubyte c1 = mask[v1], c2 = mask[v2]; \
- GLubyte c3 = mask[v3], c4 = mask[v4]; \
- GLubyte ormask = c1 | c2 | c3 | c4; \
- if (!ormask) \
- QuadFunc(ctx, v1, v2, v3, v4); \
- else if (!(c1 & c2 & c3 & c4 & 0x3f)) \
- clip_quad_4(ctx, v1, v2, v3, v4, ormask); \
- } while (0)
-
-
-#define LOCAL_VARS \
- TNLcontext *tnl = TNL_CONTEXT(ctx); \
- struct vertex_buffer *VB = &tnl->vb; \
- const GLuint * const elt = VB->Elts; \
- const GLubyte *mask = VB->ClipMask; \
- const GLuint sz = VB->ClipPtr->size; \
- const tnl_line_func LineFunc = tnl->Driver.Render.Line; \
- const tnl_triangle_func TriangleFunc = tnl->Driver.Render.Triangle; \
- const tnl_quad_func QuadFunc = tnl->Driver.Render.Quad; \
- const GLboolean stipple = ctx->Line.StippleFlag; \
- (void) (LineFunc && TriangleFunc && QuadFunc); \
- (void) elt; (void) mask; (void) sz; (void) stipple;
-
-#define POSTFIX \
- viaRasterPrimitiveFinish(ctx)
-
-#define TAG(x) clip_##x##_verts
-#define INIT(x) tnl->Driver.Render.PrimitiveNotify(ctx, x)
-#define RESET_STIPPLE if (stipple) tnl->Driver.Render.ResetLineStipple(ctx)
-#define RESET_OCCLUSION ctx->OcclusionResult = GL_TRUE
-#define PRESERVE_VB_DEFS
-#include "via_vb_rendertmp.h"
-
-
-/* Elts, with the possibility of clipping.
- */
-#undef ELT
-#undef TAG
-#define ELT(x) elt[x]
-#define TAG(x) clip_##x##_elts
-#include "via_vb_rendertmp.h"
-
-/* TODO: do this for all primitives, verts and elts:
- */
-static void clip_elt_triangles(GLcontext *ctx,
- GLuint start,
- GLuint count,
- GLuint flags)
-{
- TNLcontext *tnl = TNL_CONTEXT(ctx);
- tnl_render_func render_tris = tnl->Driver.Render.PrimTabElts[GL_TRIANGLES];
- struct vertex_buffer *VB = &tnl->vb;
- const GLuint * const elt = VB->Elts;
- GLubyte *mask = VB->ClipMask;
- GLuint last = count-2;
- GLuint j;
- (void)flags;
-#ifdef PERFORMANCE_MEASURE
- if (VIA_PERFORMANCE) P_M;
-#endif
- tnl->Driver.Render.PrimitiveNotify(ctx, GL_TRIANGLES);
-
- for (j = start; j < last; j += 3) {
- GLubyte c1 = mask[elt[j]];
- GLubyte c2 = mask[elt[j + 1]];
- GLubyte c3 = mask[elt[j + 2]];
- GLubyte ormask = c1 | c2 | c3;
- if (ormask) {
- if (start < j)
- render_tris(ctx, start, j, 0);
- if (!(c1 & c2 & c3 & 0x3f))
- clip_tri_4(ctx, elt[j], elt[j + 1], elt[j + 2], ormask);
- start = j+3;
- }
- }
-
- if (start < j)
- render_tris(ctx, start, j, 0);
-
- viaRasterPrimitiveFinish(ctx);
-}
-
-
-/**********************************************************************/
-/* Helper functions for drivers */
-/**********************************************************************/
-/*
-void _tnl_RenderClippedPolygon(GLcontext *ctx, const GLuint *elts, GLuint n)
-{
- TNLcontext *tnl = TNL_CONTEXT(ctx);
- struct vertex_buffer *VB = &tnl->vb;
- GLuint *tmp = VB->Elts;
-
- VB->Elts = (GLuint *)elts;
- tnl->Driver.Render.PrimTabElts[GL_POLYGON](ctx, 0, n, PRIM_BEGIN|PRIM_END);
- VB->Elts = tmp;
-}
-
-void _tnl_RenderClippedLine(GLcontext *ctx, GLuint ii, GLuint jj)
-{
- TNLcontext *tnl = TNL_CONTEXT(ctx);
- tnl->Driver.Render.Line(ctx, ii, jj);
-}
-*/
-
-/**********************************************************************/
-/* Render pipeline stage */
-/**********************************************************************/
-static GLboolean via_run_render(GLcontext *ctx,
- struct tnl_pipeline_stage *stage)
-{
- TNLcontext *tnl = TNL_CONTEXT(ctx);
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
- struct vertex_buffer *VB = &tnl->vb;
- /* DBG */
- GLuint newInputs = stage->changed_inputs;
- /*GLuint newInputs = stage->inputs;*/
-
- tnl_render_func *tab;
- GLuint pass = 0;
-
-#ifdef DEBUG
- if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
-#endif
-#ifdef PERFORMANCE_MEASURE
- if (VIA_PERFORMANCE) P_M;
-#endif
- tnl->Driver.Render.Start(ctx);
- tnl->Driver.Render.BuildVertices(ctx, 0, VB->Count, newInputs);
- if (VB->ClipOrMask) {
- tab = VB->Elts ? clip_render_tab_elts : clip_render_tab_verts;
- clip_render_tab_elts[GL_TRIANGLES] = clip_elt_triangles;
- }
- else {
- tab = VB->Elts ? tnl->Driver.Render.PrimTabElts : tnl->Driver.Render.PrimTabVerts;
- }
-
- do {
- GLuint i;
-
- for (i = 0; i < VB->PrimitiveCount; i++) {
- GLuint flags = VB->Primitive[i].mode;
- GLuint start = VB->Primitive[i].start;
- GLuint length= VB->Primitive[i].count;
- ASSERT(length || (flags & PRIM_END));
- ASSERT((flags & PRIM_MODE_MASK) <= GL_POLYGON + 1);
- if (length)
- tab[flags & PRIM_MODE_MASK](ctx, start, start + length,flags);
- }
- }
- while (tnl->Driver.Render.Multipass && tnl->Driver.Render.Multipass(ctx, ++pass));
- tnl->Driver.Render.Finish(ctx);
-
- /*=* DBG - flush : if hw idel *=*/
- /*{
- GLuint volatile *pnEnginStatus = vmesa->regEngineStatus;
- GLuint nStatus;
- nStatus = *pnEnginStatus;
- if ((nStatus & 0xFFFEFFFF) == 0x00020000)
- viaFlushPrims(vmesa);
- }*/
-
- /*=* DBG viewperf7.0 : fix command buffer overflow *=*/
- if (vmesa->dmaLow > (vmesa->dma[0].size / 2))
- viaFlushPrims(vmesa);
-#ifdef DEBUG
- if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
-#endif
- return GL_FALSE; /* finished the pipe */
-}
-
-/* Quite a bit of work involved in finding out the inputs for the
- * render stage.
- */
-
-static void via_check_render(GLcontext *ctx, struct tnl_pipeline_stage *stage)
-{
- GLuint inputs = VERT_BIT_CLIP;
-
- if (ctx->Visual.rgbMode) {
- inputs |= VERT_BIT_COLOR0;
-
- if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)
- inputs |= VERT_BIT_COLOR1;
-
- if (ctx->Texture.Unit[0]._ReallyEnabled) {
- inputs |= VERT_BIT_TEX0;
- }
-
- if (ctx->Texture.Unit[1]._ReallyEnabled) {
- inputs |= VERT_BIT_TEX1;
- }
- }
- else {
- /*inputs |= VERT_BIT_INDEX;*/
- }
-
- /*if (ctx->Point._Attenuated)
- inputs |= VERT_POINT_SIZE;*/
-
- if (ctx->Fog.Enabled)
- inputs |= VERT_BIT_FOG;
-
- /*if (ctx->_TriangleCaps & DD_TRI_UNFILLED)
- inputs |= VERT_EDGE;
-
- if (ctx->RenderMode == GL_FEEDBACK)
- inputs |= VERT_TEX_ANY;*/
-
- stage->inputs = inputs;
-}
-
-
-static void dtr(struct tnl_pipeline_stage *stage)
-{
- (void)stage;
-}
-
-
-const struct tnl_pipeline_stage _via_render_stage =
-{
- "via render",
- (_NEW_BUFFERS |
- _DD_NEW_SEPARATE_SPECULAR |
- _DD_NEW_FLATSHADE |
- _NEW_TEXTURE |
- _NEW_LIGHT |
- _NEW_POINT |
- _NEW_FOG |
- _DD_NEW_TRI_UNFILLED |
- _NEW_RENDERMODE), /* re-check (new inputs) */
- 0, /* re-run (always runs) */
- GL_TRUE, /* active */
- 0, 0, /* inputs (set in check_render), outputs */
- 0, 0, /* changed_inputs, private */
- dtr, /* destructor */
- via_check_render, /* check - initially set to alloc data */
- via_run_render /* run */
-};