summaryrefslogtreecommitdiffstats
path: root/src/mesa/swrast
diff options
context:
space:
mode:
Diffstat (limited to 'src/mesa/swrast')
-rw-r--r--src/mesa/swrast/s_context.c63
-rw-r--r--src/mesa/swrast/s_context.h10
-rw-r--r--src/mesa/swrast/s_pointtemp.h285
-rw-r--r--src/mesa/swrast/swrast.h7
4 files changed, 240 insertions, 125 deletions
diff --git a/src/mesa/swrast/s_context.c b/src/mesa/swrast/s_context.c
index e85741953e7..8decd1c4a6e 100644
--- a/src/mesa/swrast/s_context.c
+++ b/src/mesa/swrast/s_context.c
@@ -1,4 +1,4 @@
-/* $Id: s_context.c,v 1.38 2002/09/17 15:46:34 brianp Exp $ */
+/* $Id: s_context.c,v 1.39 2002/10/04 17:37:46 brianp Exp $ */
/*
* Mesa 3-D graphics library
@@ -33,11 +33,12 @@
#include "mem.h"
#include "swrast.h"
-#include "s_points.h"
-#include "s_lines.h"
-#include "s_triangle.h"
#include "s_blend.h"
#include "s_context.h"
+#include "s_lines.h"
+#include "s_points.h"
+#include "s_span.h"
+#include "s_triangle.h"
#include "s_texture.h"
@@ -513,19 +514,26 @@ _swrast_CreateContext( GLcontext *ctx )
for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++)
swrast->TextureSample[i] = _swrast_validate_texture_sample;
- swrast->span_data = MALLOC_STRUCT(span_arrays);
- if (!swrast->span_data) {
+ swrast->SpanArrays = MALLOC_STRUCT(span_arrays);
+ if (!swrast->SpanArrays) {
FREE(swrast);
return GL_FALSE;
}
+ /* init point span buffer */
+ swrast->PointSpan.primitive = GL_POINT;
+ swrast->PointSpan.start = 0;
+ swrast->PointSpan.end = 0;
+ swrast->PointSpan.facing = 0;
+ swrast->PointSpan.array = swrast->SpanArrays;
+
assert(ctx->Const.MaxTextureUnits > 0);
assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_UNITS);
swrast->TexelBuffer = (GLchan *) MALLOC(ctx->Const.MaxTextureUnits *
MAX_WIDTH * 4 * sizeof(GLchan));
if (!swrast->TexelBuffer) {
- FREE(swrast->span_data);
+ FREE(swrast->SpanArrays);
FREE(swrast);
return GL_FALSE;
}
@@ -544,7 +552,7 @@ _swrast_DestroyContext( GLcontext *ctx )
_mesa_debug(ctx, "_swrast_DestroyContext\n");
}
- FREE( swrast->span_data );
+ FREE( swrast->SpanArrays );
FREE( swrast->TexelBuffer );
FREE( swrast );
@@ -559,6 +567,35 @@ _swrast_GetDeviceDriverReference( GLcontext *ctx )
return &swrast->Driver;
}
+void
+_swrast_flush( GLcontext *ctx )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ /* flush any pending fragments from rendering points */
+ if (swrast->PointSpan.end > 0) {
+ if (ctx->Visual.rgbMode) {
+ if (ctx->Texture._EnabledUnits)
+ _mesa_write_texture_span(ctx, &(swrast->PointSpan));
+ else
+ _mesa_write_rgba_span(ctx, &(swrast->PointSpan));
+ }
+ else {
+ _mesa_write_index_span(ctx, &(swrast->PointSpan));
+ }
+ swrast->PointSpan.end = 0;
+ }
+}
+
+void
+_swrast_render_primitive( GLcontext *ctx, GLenum prim )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ if (swrast->Primitive == GL_POINTS && prim != GL_POINTS) {
+ _swrast_flush(ctx);
+ }
+ swrast->Primitive = prim;
+}
+
void
_swrast_render_start( GLcontext *ctx )
@@ -566,6 +603,7 @@ _swrast_render_start( GLcontext *ctx )
SWcontext *swrast = SWRAST_CONTEXT(ctx);
if (swrast->Driver.SpanRenderStart)
swrast->Driver.SpanRenderStart( ctx );
+ swrast->PointSpan.end = 0;
}
void
@@ -574,6 +612,8 @@ _swrast_render_finish( GLcontext *ctx )
SWcontext *swrast = SWRAST_CONTEXT(ctx);
if (swrast->Driver.SpanRenderFinish)
swrast->Driver.SpanRenderFinish( ctx );
+
+ _swrast_flush(ctx);
}
@@ -613,10 +653,3 @@ _swrast_print_vertex( GLcontext *ctx, const SWvertex *v )
_mesa_debug(ctx, "\n");
}
}
-
-
-void
-_swrast_flush( GLcontext *ctx )
-{
- /* no-op */
-}
diff --git a/src/mesa/swrast/s_context.h b/src/mesa/swrast/s_context.h
index a2c14f07a73..ecf173adbcb 100644
--- a/src/mesa/swrast/s_context.h
+++ b/src/mesa/swrast/s_context.h
@@ -1,4 +1,4 @@
-/* $Id: s_context.h,v 1.19 2002/08/07 00:45:07 brianp Exp $ */
+/* $Id: s_context.h,v 1.20 2002/10/04 17:37:47 brianp Exp $ */
/*
* Mesa 3-D graphics library
@@ -137,6 +137,7 @@ typedef struct
GLuint StippleCounter; /**< Line stipple counter */
GLuint NewState;
GLuint StateChanges;
+ GLenum Primitive; /* current primitive being drawn (ala glBegin) */
/** Mechanism to allow driver (like X11) to register further
* software rasterization routines.
@@ -176,7 +177,12 @@ typedef struct
* this object is big and causes problems when allocated on the stack
* on some systems.
*/
- struct span_arrays *span_data;
+ struct span_arrays *SpanArrays;
+
+ /**
+ * Used to buffer N GL_POINTS, instead of rendering one by one.
+ */
+ struct sw_span PointSpan;
/** Internal hooks, kept uptodate by the same mechanism as above.
*/
diff --git a/src/mesa/swrast/s_pointtemp.h b/src/mesa/swrast/s_pointtemp.h
index be8783b6949..cf45dcde825 100644
--- a/src/mesa/swrast/s_pointtemp.h
+++ b/src/mesa/swrast/s_pointtemp.h
@@ -1,4 +1,4 @@
-/* $Id: s_pointtemp.h,v 1.18 2002/08/07 00:45:07 brianp Exp $ */
+/* $Id: s_pointtemp.h,v 1.19 2002/10/04 17:37:47 brianp Exp $ */
/*
* Mesa 3-D graphics library
@@ -61,23 +61,32 @@
static void
NAME ( GLcontext *ctx, const SWvertex *vert )
{
-#if FLAGS & TEXTURE
- GLuint u;
-#endif
#if FLAGS & (ATTENUATE | LARGE | SMOOTH | SPRITE)
GLfloat size;
#endif
#if FLAGS & ATTENUATE
GLfloat alphaAtten;
#endif
-#if (FLAGS & RGBA) && (FLAGS & SMOOTH)
+#if FLAGS & RGBA
const GLchan red = vert->color[0];
const GLchan green = vert->color[1];
const GLchan blue = vert->color[2];
const GLchan alpha = vert->color[3];
#endif
-
- struct sw_span span;
+#if FLAGS & SPECULAR
+ const GLchan specRed = vert->specular[0];
+ const GLchan specGreen = vert->specular[1];
+ const GLchan specBlue = vert->specular[2];
+#endif
+#if FLAGS & INDEX
+ const GLuint colorIndex = vert->index;
+#endif
+#if FLAGS & TEXTURE
+ GLfloat texcoord[MAX_TEXTURE_UNITS][4];
+ GLuint u;
+#endif
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ struct sw_span *span = &(swrast->PointSpan);
/* Cull primitives with malformed coordinates.
*/
@@ -87,59 +96,40 @@ NAME ( GLcontext *ctx, const SWvertex *vert )
return;
}
- INIT_SPAN(span, GL_POINT, 0, SPAN_FOG, SPAN_XY | SPAN_Z);
- span.fog = vert->fog;
- span.fogStep = 0.0;
-
-#if (FLAGS & RGBA)
-#if (FLAGS & SMOOTH)
- /* because we need per-fragment alpha values */
- span.arrayMask |= SPAN_RGBA;
-#else
- /* same RGBA for all fragments */
- span.interpMask |= SPAN_RGBA;
- span.red = ChanToFixed(vert->color[0]);
- span.green = ChanToFixed(vert->color[1]);
- span.blue = ChanToFixed(vert->color[2]);
- span.alpha = ChanToFixed(vert->color[3]);
- span.redStep = span.greenStep = span.blueStep = span.alphaStep = 0;
-#endif /*SMOOTH*/
-#endif /*RGBA*/
+ /*
+ * Span init
+ */
+ span->interpMask = SPAN_FOG;
+ span->arrayMask = SPAN_XY | SPAN_Z;
+ span->fog = vert->fog;
+ span->fogStep = 0.0;
+#if FLAGS & RGBA
+ span->arrayMask |= SPAN_RGBA;
+#endif
#if FLAGS & SPECULAR
- span.interpMask |= SPAN_SPEC;
- span.specRed = ChanToFixed(vert->specular[0]);
- span.specGreen = ChanToFixed(vert->specular[1]);
- span.specBlue = ChanToFixed(vert->specular[2]);
- span.specRedStep = span.specGreenStep = span.specBlueStep = 0;
+ span->arrayMask |= SPAN_SPEC;
#endif
#if FLAGS & INDEX
- span.interpMask |= SPAN_INDEX;
- span.index = IntToFixed(vert->index);
- span.indexStep = 0;
+ span->arrayMask |= SPAN_INDEX;
#endif
#if FLAGS & TEXTURE
- /* but not used for sprite mode */
- span.interpMask |= SPAN_TEXTURE;
+ span->arrayMask |= SPAN_TEXTURE;
for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
if (ctx->Texture.Unit[u]._ReallyEnabled) {
const GLfloat q = vert->texcoord[u][3];
const GLfloat invQ = (q == 0.0 || q == 1.0) ? 1.0 : (1.0 / q);
- span.tex[u][0] = vert->texcoord[u][0] * invQ;
- span.tex[u][1] = vert->texcoord[u][1] * invQ;
- span.tex[u][2] = vert->texcoord[u][2] * invQ;
- span.tex[u][3] = q;
- span.texStepX[u][0] = span.texStepY[u][0] = 0.0;
- span.texStepX[u][1] = span.texStepY[u][1] = 0.0;
- span.texStepX[u][2] = span.texStepY[u][2] = 0.0;
- span.texStepX[u][3] = span.texStepY[u][3] = 0.0;
+ texcoord[u][0] = vert->texcoord[u][0] * invQ;
+ texcoord[u][1] = vert->texcoord[u][1] * invQ;
+ texcoord[u][2] = vert->texcoord[u][2] * invQ;
+ texcoord[u][3] = q;
}
}
#endif
#if FLAGS & SMOOTH
- span.arrayMask |= SPAN_COVERAGE;
+ span->arrayMask |= SPAN_COVERAGE;
#endif
#if FLAGS & SPRITE
- span.arrayMask |= SPAN_TEXTURE;
+ span->arrayMask |= SPAN_TEXTURE;
#endif
#if FLAGS & ATTENUATE
@@ -156,12 +146,15 @@ NAME ( GLcontext *ctx, const SWvertex *vert )
size = ctx->Point._Size;
#endif
-#if FLAGS & (LARGE | ATTENUATE | SMOOTH | SPRITE)
- {
+#if FLAGS & (ATTENUATE | LARGE | SMOOTH | SPRITE)
+ /*
+ * Multi-pixel points
+ */
+ {{
GLint x, y;
const GLfloat radius = 0.5F * size;
const GLint z = (GLint) (vert->win[2]);
- GLuint count = 0;
+ GLuint count;
#if FLAGS & SMOOTH
const GLfloat rmin = radius - 0.7071F; /* 0.7071 = sqrt(2)/2 */
const GLfloat rmax = radius + 0.7071F;
@@ -195,104 +188,184 @@ NAME ( GLcontext *ctx, const SWvertex *vert )
}
#endif /*SMOOTH*/
+ /* check if we need to flush */
+ if (span->end + (xmax-xmin+1) * (ymax-ymin+1) >= MAX_WIDTH ||
+ (swrast->_RasterMask & (BLEND_BIT | LOGIC_OP_BIT | MASKING_BIT))) {
+#if FLAGS & (TEXTURE | SPRITE)
+ if (ctx->Texture._EnabledUnits)
+ _mesa_write_texture_span(ctx, span);
+ else
+ _mesa_write_rgba_span(ctx, span);
+#elif FLAGS & RGBA
+ _mesa_write_rgba_span(ctx, span);
+#else
+ _mesa_write_index_span(ctx, span);
+#endif
+ span->end = 0;
+ }
+
+ /*
+ * OK, generate fragments
+ */
+ count = span->end;
(void) radius;
for (y = ymin; y <= ymax; y++) {
for (x = xmin; x <= xmax; x++) {
-#if FLAGS & SPRITE
+#if FLAGS & (SPRITE | TEXTURE)
GLuint u;
#endif
+
+#if FLAGS & RGBA
+ span->array->rgba[count][RCOMP] = red;
+ span->array->rgba[count][GCOMP] = green;
+ span->array->rgba[count][BCOMP] = blue;
+ span->array->rgba[count][ACOMP] = alpha;
+#endif
+#if FLAGS & SPECULAR
+ span->array->spec[count][RCOMP] = specRed;
+ span->array->spec[count][GCOMP] = specGreen;
+ span->array->spec[count][BCOMP] = specBlue;
+#endif
+#if FLAGS & INDEX
+ span->array->index[count] = colorIndex;
+#endif
+#if FLAGS & TEXTURE
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u]._ReallyEnabled) {
+ COPY_4V(span->array->texcoords[u][count], texcoord[u]);
+ }
+ }
+#endif
+
#if FLAGS & SMOOTH
/* compute coverage */
- const GLfloat dx = x - vert->win[0] + 0.5F;
- const GLfloat dy = y - vert->win[1] + 0.5F;
- const GLfloat dist2 = dx * dx + dy * dy;
- if (dist2 < rmax2) {
- if (dist2 >= rmin2) {
- /* compute partial coverage */
- span.array->coverage[count] = 1.0F - (dist2 - rmin2) * cscale;
+ {
+ const GLfloat dx = x - vert->win[0] + 0.5F;
+ const GLfloat dy = y - vert->win[1] + 0.5F;
+ const GLfloat dist2 = dx * dx + dy * dy;
+ if (dist2 < rmax2) {
+ if (dist2 >= rmin2) {
+ /* compute partial coverage */
+ span->array->coverage[count] = 1.0F - (dist2 - rmin2) * cscale;
#if FLAGS & INDEX
- span.array->coverage[count] *= 15.0; /* coverage in [0,15] */
+ /* coverage in [0,15] */
+ span->array->coverage[count] *= 15.0;
#endif
- }
- else {
- /* full coverage */
- span.array->coverage[count] = 1.0F;
- }
+ }
+ else {
+ /* full coverage */
+ span->array->coverage[count] = 1.0F;
+ }
- span.array->x[count] = x;
- span.array->y[count] = y;
- span.array->z[count] = z;
+ span->array->x[count] = x;
+ span->array->y[count] = y;
+ span->array->z[count] = z;
-#if FLAGS & RGBA
- span.array->rgba[count][RCOMP] = red;
- span.array->rgba[count][GCOMP] = green;
- span.array->rgba[count][BCOMP] = blue;
-#if FLAGS & ATTENUATE
- span.array->rgba[count][ACOMP] = (GLchan) (alpha * alphaAtten);
-#else
- span.array->rgba[count][ACOMP] = alpha;
+#if (FLAGS & ATTENUATE) && (FLAGS & RGBA)
+ span->array->rgba[count][ACOMP] = (GLchan) (alpha * alphaAtten);
+#elif FLAGS & RGBA
+ span->array->rgba[count][ACOMP] = alpha;
#endif /*ATTENUATE*/
-#endif /*RGBA*/
- count++;
- } /*if*/
+ count++;
+ } /*if*/
+ }
+
#else /*SMOOTH*/
+
/* not smooth (square points) */
- span.array->x[count] = x;
- span.array->y[count] = y;
- span.array->z[count] = z;
+ span->array->x[count] = x;
+ span->array->y[count] = y;
+ span->array->z[count] = z;
+
#if FLAGS & SPRITE
for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
if (ctx->Texture.Unit[u]._ReallyEnabled) {
if (ctx->Point.CoordReplace[u]) {
GLfloat s = 0.5F + (x + 0.5F - vert->win[0]) / size;
GLfloat t = 0.5F - (y + 0.5F - vert->win[1]) / size;
- span.array->texcoords[u][count][0] = s;
- span.array->texcoords[u][count][1] = t;
- span.array->texcoords[u][count][3] = 1.0F;
+ span->array->texcoords[u][count][0] = s;
+ span->array->texcoords[u][count][1] = t;
+ span->array->texcoords[u][count][3] = 1.0F;
if (ctx->Point.SpriteRMode == GL_ZERO)
- span.array->texcoords[u][count][2] = 0.0F;
+ span->array->texcoords[u][count][2] = 0.0F;
else if (ctx->Point.SpriteRMode == GL_S)
- span.array->texcoords[u][count][2] = vert->texcoord[u][0];
+ span->array->texcoords[u][count][2] = vert->texcoord[u][0];
else /* GL_R */
- span.array->texcoords[u][count][2] = vert->texcoord[u][2];
+ span->array->texcoords[u][count][2] = vert->texcoord[u][2];
}
else {
- COPY_4V(span.array->texcoords[u][count], vert->texcoord[u]);
+ COPY_4V(span->array->texcoords[u][count], vert->texcoord[u]);
}
}
}
#endif /*SPRITE*/
- count++;
+
+ count++; /* square point */
+
#endif /*SMOOTH*/
+
} /*for x*/
} /*for y*/
- span.end = count;
- }
+ span->end = count;
+ }}
#else /* LARGE | ATTENUATE | SMOOTH | SPRITE */
- {
- /* size == 1 */
- span.array->x[0] = (GLint) vert->win[0];
- span.array->y[0] = (GLint) vert->win[1];
- span.array->z[0] = (GLint) vert->win[2];
- span.end = 1;
- }
-
-#endif /* LARGE || ATTENUATE || SMOOTH */
-
- ASSERT(span.end > 0);
+ /*
+ * Single-pixel points
+ */
+ {{
+ GLuint count;
+ /* check if we need to flush */
+ if (span->end >= MAX_WIDTH ||
+ (swrast->_RasterMask & (BLEND_BIT | LOGIC_OP_BIT | MASKING_BIT))) {
#if FLAGS & (TEXTURE | SPRITE)
- if (ctx->Texture._EnabledUnits)
- _mesa_write_texture_span(ctx, &span);
- else
- _mesa_write_rgba_span(ctx, &span);
+ if (ctx->Texture._EnabledUnits)
+ _mesa_write_texture_span(ctx, span);
+ else
+ _mesa_write_rgba_span(ctx, span);
#elif FLAGS & RGBA
- _mesa_write_rgba_span(ctx, &span);
+ _mesa_write_rgba_span(ctx, span);
#else
- _mesa_write_index_span(ctx, &span);
+ _mesa_write_index_span(ctx, span);
+#endif
+ span->end = 0;
+ }
+
+ count = span->end;
+
+#if FLAGS & RGBA
+ span->array->rgba[count][RCOMP] = red;
+ span->array->rgba[count][GCOMP] = green;
+ span->array->rgba[count][BCOMP] = blue;
+ span->array->rgba[count][ACOMP] = alpha;
+#endif
+#if FLAGS & SPECULAR
+ span->array->spec[count][RCOMP] = specRed;
+ span->array->spec[count][GCOMP] = specGreen;
+ span->array->spec[count][BCOMP] = specBlue;
+#endif
+#if FLAGS & INDEX
+ span->array->index[count] = colorIndex;
+#endif
+#if FLAGS & TEXTURE
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u]._ReallyEnabled) {
+ COPY_4V(span->array->texcoords[u][count], texcoord[u]);
+ }
+ }
#endif
+
+ span->array->x[count] = (GLint) vert->win[0];
+ span->array->y[count] = (GLint) vert->win[1];
+ span->array->z[count] = (GLint) vert->win[2];
+ span->end = count + 1;
+ }}
+
+#endif /* LARGE || ATTENUATE || SMOOTH */
+
+ ASSERT(span->end <= MAX_WIDTH);
}
diff --git a/src/mesa/swrast/swrast.h b/src/mesa/swrast/swrast.h
index 2d547c889ea..1cb55a9d8c8 100644
--- a/src/mesa/swrast/swrast.h
+++ b/src/mesa/swrast/swrast.h
@@ -1,4 +1,4 @@
-/* $Id: swrast.h,v 1.28 2002/10/02 23:24:04 brianp Exp $ */
+/* $Id: swrast.h,v 1.29 2002/10/04 17:37:47 brianp Exp $ */
/*
* Mesa 3-D graphics library
@@ -205,7 +205,7 @@ do { \
(S).start = 0; \
(S).end = (END); \
(S).facing = 0; \
- (S).array = SWRAST_CONTEXT(ctx)->span_data; \
+ (S).array = SWRAST_CONTEXT(ctx)->SpanArrays; \
} while (0)
@@ -307,6 +307,9 @@ extern void
_swrast_flush( GLcontext *ctx );
extern void
+_swrast_render_primitive( GLcontext *ctx, GLenum mode );
+
+extern void
_swrast_render_start( GLcontext *ctx );
extern void
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-02 23:33:45 +0000