-/* $Id: osmesa.c,v 1.71 2001/09/25 17:38:11 keithw Exp $ */
+/* $Id: osmesa.c,v 1.72 2001/12/17 04:56:29 brianp Exp $ */
/*
* Mesa 3-D graphics library
#include "swrast/s_depth.h"
#include "swrast/s_lines.h"
#include "swrast/s_triangle.h"
-#include "swrast/s_trispan.h"
#include "tnl/tnl.h"
#include "tnl/t_context.h"
#include "tnl/t_pipeline.h"
#define RENDER_SPAN( span ) \
GLuint i; \
GLchan *img = PIXELADDR4(span.x, span.y); \
- for (i = 0; i < span.count; i++, img += 4) { \
+ for (i = 0; i < span.end; i++, img += 4) { \
const GLdepth z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
PACK_RGBA(img, FixedToChan(span.red), \
#define RENDER_SPAN( span ) \
GLuint i; \
GLuint *img = (GLuint *) PIXELADDR4(span.x, span.y); \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
const GLdepth z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
img[i] = pixel; \
-/* $Id: xm_tri.c,v 1.20 2001/05/14 16:23:04 brianp Exp $ */
+/* $Id: xm_tri.c,v 1.21 2001/12/17 04:56:29 brianp Exp $ */
/*
* Mesa 3-D graphics library
#include "glxheader.h"
#include "depth.h"
#include "macros.h"
+#include "mem.h"
#include "mmath.h"
#include "mtypes.h"
#include "xmesaP.h"
#include "swrast/s_context.h"
#include "swrast/s_depth.h"
#include "swrast/s_triangle.h"
-#include "swrast/s_trispan.h"
#define RENDER_SPAN( span ) \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
GLuint i; \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
unsigned long p; \
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = PACK_8B8G8R(FixedToInt(span.red), \
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
PIXEL_TYPE *ptr = pRow + i; \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
unsigned long p; \
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = PACK_5R6G5B(FixedToInt(span.red), \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
XDITHER_SETUP(y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red),\
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
XDITHER_SETUP(y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
unsigned long p = XDITHER(x, FixedToInt(span.red), \
#define RENDER_SPAN( span ) \
GLuint i; \
LOOKUP_SETUP; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = LOOKUP(FixedToInt(span.red), \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
XMesaPutPixel(img, x, y, pixel); \
v2->color[1], v2->color[2] );
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = (PIXEL_TYPE) p; \
v2->color[1], v2->color[2] );
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = (PIXEL_TYPE) p; \
#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
PIXEL_TYPE *ptr = pRow + i; \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
unsigned long p; \
v2->color[1], v2->color[2] );
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = (PIXEL_TYPE) p; \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, y)); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
FLAT_DITHER_ROW_SETUP(y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
unsigned long p = FLAT_DITHER(x); \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
GLubyte p = LOOKUP(r,g,b);
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = p; \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
unsigned long p; \
PACK_TRUECOLOR(p, FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue)); \
#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
pRow[i] = PACK_8B8G8R(FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue) ); \
span.red += span.redStep; \
#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue) ); \
span.red += span.redStep; \
#define RENDER_SPAN( span ) \
GLuint i; \
PIXEL_TYPE *pixel = pRow; \
- for (i = 0; i < span.count; i++, pixel++) { \
+ for (i = 0; i < span.end; i++, pixel++) { \
pixel->r = FixedToInt(span.red); \
pixel->g = FixedToInt(span.green); \
pixel->b = FixedToInt(span.blue); \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
unsigned long p; \
PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue)); \
#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue)); \
span.red += span.redStep; \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue)); \
span.red += span.redStep; \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
XDITHER_SETUP(y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue) ); \
span.red += span.redStep; \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
XDITHER_SETUP(y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
unsigned long p = XDITHER(x, FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue) ); \
XMesaPutPixel(img, x, y, p); \
#define RENDER_SPAN( span ) \
GLuint i; \
LOOKUP_SETUP; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
pRow[i] = LOOKUP(FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue));\
span.red += span.redStep; \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue)); \
span.red += span.redStep; \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
XMesaPutPixel(img, x, y, pixel); \
}
v2->color[1], v2->color[2] );
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
pRow[i] = (PIXEL_TYPE) p; \
}
v2->color[1], v2->color[2] );
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
pRow[i] = (PIXEL_TYPE) p; \
}
#define RENDER_SPAN( span ) \
GLuint i; \
PIXEL_TYPE *pixel = pRow; \
- for (i = 0; i < span.count; i++, pixel++) { \
+ for (i = 0; i < span.end; i++, pixel++) { \
pixel->r = color[RCOMP]; \
pixel->g = color[GCOMP]; \
pixel->b = color[BCOMP]; \
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
unsigned long p; \
PACK_TRUEDITHER(p, x, y, v2->color[0], \
v2->color[1], v2->color[2] ); \
v2->color[1], v2->color[2] );
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
pRow[i] = (PIXEL_TYPE) p; \
}
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
color[GCOMP], color[BCOMP]); \
}
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, y)); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
}
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
FLAT_DITHER_ROW_SETUP(y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
unsigned long p = FLAT_DITHER(x); \
XMesaPutPixel(img, x, y, p ); \
}
#define RENDER_SPAN( span ) \
GLuint i; \
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
- for (i = 0; i < span.count; i++, x++) { \
+ for (i = 0; i < span.end; i++, x++) { \
pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
}
GLubyte p = LOOKUP(r,g,b);
#define RENDER_SPAN( span ) \
GLuint i; \
- for (i = 0; i < span.count; i++) { \
+ for (i = 0; i < span.end; i++) { \
pRow[i] = (PIXEL_TYPE) p; \
}
-/* $Id: s_aatriangle.c,v 1.20 2001/11/13 00:26:39 brianp Exp $ */
+/* $Id: s_aatriangle.c,v 1.21 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
/*
* Compute coefficients of a plane using the X,Y coords of the v0, v1, v2
* vertices and the given Z values.
+ * A point (x,y,z) lies on plane iff a*x+b*y+c*z+d = 0.
*/
static INLINE void
compute_plane(const GLfloat v0[], const GLfloat v1[], const GLfloat v2[],
const GLfloat qy = v2[1] - v0[1];
const GLfloat qz = z2 - z0;
+ /* Crossproduct "(a,b,c):= dv1 x dv2" is orthogonal to plane. */
const GLfloat a = py * qz - pz * qy;
const GLfloat b = pz * qx - px * qz;
const GLfloat c = px * qy - py * qx;
+ /* Point on the plane = "r*(a,b,c) + w", with fixed "r" depending
+ on the distance of plane from origin and arbitrary "w" parallel
+ to the plane. */
+ /* The scalar product "(r*(a,b,c)+w)*(a,b,c)" is "r*(a^2+b^2+c^2)",
+ which is equal to "-d" below. */
const GLfloat d = -(a * v0[0] + b * v0[1] + c * z0);
plane[0] = a;
static INLINE GLfloat
solve_plane(GLfloat x, GLfloat y, const GLfloat plane[4])
{
- const GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
- return z;
+ ASSERT(plane[2] != 0.0F);
+ return (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
}
#ifdef DEBUG
{
const GLfloat area = dx0 * dy1 - dx1 * dy0;
- assert(area >= 0.0);
+ ASSERT(area >= 0.0);
}
#endif
#ifdef DEBUG
{
const GLfloat area = dx0 * dy1 - dx1 * dy0;
- assert(area >= 0.0);
+ ASSERT(area >= 0.0);
}
#endif
-/* $Id: s_aatritemp.h,v 1.22 2001/12/05 10:24:31 keithw Exp $ */
+/* $Id: s_aatritemp.h,v 1.23 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
GLfloat yMin, yMax;
GLboolean ltor;
GLfloat majDx, majDy; /* major (i.e. long) edge dx and dy */
-
+
+ struct sw_span span;
+
#ifdef DO_Z
GLfloat zPlane[4];
GLdepth z[MAX_WIDTH];
#endif
#ifdef DO_RGBA
GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4];
- DEFMARRAY(GLchan, rgba, MAX_WIDTH, 4); /* mac 32k limitation */
#endif
#ifdef DO_INDEX
GLfloat iPlane[4];
- GLuint index[MAX_WIDTH];
GLint icoverageSpan[MAX_WIDTH];
#else
GLfloat coverageSpan[MAX_WIDTH];
#endif
#ifdef DO_SPEC
GLfloat srPlane[4], sgPlane[4], sbPlane[4];
- DEFMARRAY(GLchan, spec, MAX_WIDTH, 4);
#endif
#ifdef DO_TEX
GLfloat sPlane[4], tPlane[4], uPlane[4], vPlane[4];
GLfloat texWidth, texHeight;
- DEFARRAY(GLfloat, s, MAX_WIDTH); /* mac 32k limitation */
- DEFARRAY(GLfloat, t, MAX_WIDTH);
- DEFARRAY(GLfloat, u, MAX_WIDTH);
- DEFARRAY(GLfloat, lambda, MAX_WIDTH);
#elif defined(DO_MULTITEX)
GLfloat sPlane[MAX_TEXTURE_UNITS][4];
GLfloat tPlane[MAX_TEXTURE_UNITS][4];
GLfloat uPlane[MAX_TEXTURE_UNITS][4];
GLfloat vPlane[MAX_TEXTURE_UNITS][4];
GLfloat texWidth[MAX_TEXTURE_UNITS], texHeight[MAX_TEXTURE_UNITS];
- DEFMARRAY(GLfloat, s, MAX_TEXTURE_UNITS, MAX_WIDTH); /* mac 32k limit */
- DEFMARRAY(GLfloat, t, MAX_TEXTURE_UNITS, MAX_WIDTH);
- DEFMARRAY(GLfloat, u, MAX_TEXTURE_UNITS, MAX_WIDTH);
- DEFMARRAY(GLfloat, lambda, MAX_TEXTURE_UNITS, MAX_WIDTH);
#endif
GLfloat bf = SWRAST_CONTEXT(ctx)->_backface_sign;
-
-#ifdef DO_RGBA
- CHECKARRAY(rgba, return); /* mac 32k limitation */
-#endif
-#ifdef DO_SPEC
- CHECKARRAY(spec, return);
-#endif
-#if defined(DO_TEX) || defined(DO_MULTITEX)
- CHECKARRAY(s, return);
- CHECKARRAY(t, return);
- CHECKARRAY(u, return);
- CHECKARRAY(lambda, return);
-#endif
-
+
+
/* determine bottom to top order of vertices */
{
GLfloat y0 = v0->win[1];
GLint ix, startX = (GLint) (x - xAdj);
GLuint count, n;
GLfloat coverage = 0.0F;
+ SW_SPAN_RESET(span);
+
/* skip over fragments with zero coverage */
while (startX < MAX_WIDTH) {
coverage = compute_coveragef(pMin, pMid, pMax, startX, iy);
fog[count] = solve_plane(cx, cy, fogPlane);
#endif
#ifdef DO_RGBA
- rgba[count][RCOMP] = solve_plane_chan(cx, cy, rPlane);
- rgba[count][GCOMP] = solve_plane_chan(cx, cy, gPlane);
- rgba[count][BCOMP] = solve_plane_chan(cx, cy, bPlane);
- rgba[count][ACOMP] = solve_plane_chan(cx, cy, aPlane);
+ span.color.rgba[count][RCOMP] = solve_plane_chan(cx, cy, rPlane);
+ span.color.rgba[count][GCOMP] = solve_plane_chan(cx, cy, gPlane);
+ span.color.rgba[count][BCOMP] = solve_plane_chan(cx, cy, bPlane);
+ span.color.rgba[count][ACOMP] = solve_plane_chan(cx, cy, aPlane);
#endif
#ifdef DO_INDEX
- index[count] = (GLint) solve_plane(cx, cy, iPlane);
+ span.color.index[count] = (GLint) solve_plane(cx, cy, iPlane);
#endif
#ifdef DO_SPEC
- spec[count][RCOMP] = solve_plane_chan(cx, cy, srPlane);
- spec[count][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
- spec[count][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
+ span.specular[count][RCOMP] = solve_plane_chan(cx, cy, srPlane);
+ span.specular[count][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
+ span.specular[count][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
#endif
#ifdef DO_TEX
{
const GLfloat invQ = solve_plane_recip(cx, cy, vPlane);
- s[count] = solve_plane(cx, cy, sPlane) * invQ;
- t[count] = solve_plane(cx, cy, tPlane) * invQ;
- u[count] = solve_plane(cx, cy, uPlane) * invQ;
- lambda[count] = compute_lambda(sPlane, tPlane, invQ,
- texWidth, texHeight);
+ span.texcoords[0][count][0] = solve_plane(cx, cy, sPlane) * invQ;
+ span.texcoords[0][count][1] = solve_plane(cx, cy, tPlane) * invQ;
+ span.texcoords[0][count][2] = solve_plane(cx, cy, uPlane) * invQ;
+ span.lambda[0][count] = compute_lambda(sPlane, tPlane, invQ,
+ texWidth, texHeight);
}
#elif defined(DO_MULTITEX)
{
for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
if (ctx->Texture.Unit[unit]._ReallyEnabled) {
GLfloat invQ = solve_plane_recip(cx, cy, vPlane[unit]);
- s[unit][count] = solve_plane(cx, cy, sPlane[unit]) * invQ;
- t[unit][count] = solve_plane(cx, cy, tPlane[unit]) * invQ;
- u[unit][count] = solve_plane(cx, cy, uPlane[unit]) * invQ;
- lambda[unit][count] = compute_lambda(sPlane[unit],
- tPlane[unit], invQ, texWidth[unit], texHeight[unit]);
+ span.texcoords[unit][count][0] = solve_plane(cx, cy, sPlane[unit]) * invQ;
+ span.texcoords[unit][count][1] = solve_plane(cx, cy, tPlane[unit]) * invQ;
+ span.texcoords[unit][count][2] = solve_plane(cx, cy, uPlane[unit]) * invQ;
+ span.lambda[unit][count] = compute_lambda(sPlane[unit],
+ tPlane[unit], invQ, texWidth[unit], texHeight[unit]);
}
}
}
count++;
coverage = compute_coveragef(pMin, pMid, pMax, ix, iy);
}
-
+
if (ix <= startX)
continue;
-
+
n = (GLuint) ix - (GLuint) startX;
#ifdef DO_MULTITEX
# ifdef DO_SPEC
- _mesa_write_multitexture_span(ctx, n, startX, iy, z, fog,
- (const GLfloat (*)[MAX_WIDTH]) s,
- (const GLfloat (*)[MAX_WIDTH]) t,
- (const GLfloat (*)[MAX_WIDTH]) u,
- (GLfloat (*)[MAX_WIDTH]) lambda,
- rgba, (const GLchan (*)[4]) spec,
- coverageSpan, GL_POLYGON);
+ _old_write_multitexture_span(ctx, n, startX, iy, z, fog,
+ span.texcoords,
+ span.lambda, span.color.rgba,
+ span.specular,
+ coverageSpan, GL_POLYGON);
# else
- _mesa_write_multitexture_span(ctx, n, startX, iy, z, fog,
- (const GLfloat (*)[MAX_WIDTH]) s,
- (const GLfloat (*)[MAX_WIDTH]) t,
- (const GLfloat (*)[MAX_WIDTH]) u,
- lambda, rgba, NULL, coverageSpan,
- GL_POLYGON);
+ _old_write_multitexture_span(ctx, n, startX, iy, z, fog,
+ span.texcoords,
+ span.lambda, span.color.rgba,
+ NULL, coverageSpan,
+ GL_POLYGON);
# endif
#elif defined(DO_TEX)
# ifdef DO_SPEC
- _mesa_write_texture_span(ctx, n, startX, iy, z, fog,
- s, t, u, lambda, rgba,
- (const GLchan (*)[4]) spec,
- coverageSpan, GL_POLYGON);
+ _old_write_texture_span(ctx, n, startX, iy, z, fog,
+ span.texcoords[0],
+ span.lambda[0], span.color.rgba,
+ span.specular,
+ coverageSpan, GL_POLYGON);
# else
- _mesa_write_texture_span(ctx, n, startX, iy, z, fog,
- s, t, u, lambda,
- rgba, NULL, coverageSpan, GL_POLYGON);
+ _old_write_texture_span(ctx, n, startX, iy, z, fog,
+ span.texcoords[0],
+ span.lambda[0],
+ span.color.rgba, NULL,
+ coverageSpan, GL_POLYGON);
# endif
#elif defined(DO_RGBA)
- _mesa_write_rgba_span(ctx, n, startX, iy, z, fog, rgba,
- coverageSpan, GL_POLYGON);
+ _old_write_rgba_span(ctx, n, startX, iy, z, fog, span.color.rgba,
+ coverageSpan, GL_POLYGON);
#elif defined(DO_INDEX)
- _mesa_write_index_span(ctx, n, startX, iy, z, fog, index,
- icoverageSpan, GL_POLYGON);
+ _old_write_index_span(ctx, n, startX, iy, z, fog, span.color.index,
+ icoverageSpan, GL_POLYGON);
#endif
}
}
GLint ix, left, startX = (GLint) (x + xAdj);
GLuint count, n;
GLfloat coverage = 0.0F;
-
+
/* make sure we're not past the window edge */
if (startX >= ctx->DrawBuffer->_Xmax) {
startX = ctx->DrawBuffer->_Xmax - 1;
break;
startX--;
}
-
+
/* enter interior of triangle */
ix = startX;
count = 0;
fog[ix] = solve_plane(cx, cy, fogPlane);
#endif
#ifdef DO_RGBA
- rgba[ix][RCOMP] = solve_plane_chan(cx, cy, rPlane);
- rgba[ix][GCOMP] = solve_plane_chan(cx, cy, gPlane);
- rgba[ix][BCOMP] = solve_plane_chan(cx, cy, bPlane);
- rgba[ix][ACOMP] = solve_plane_chan(cx, cy, aPlane);
+ span.color.rgba[ix][RCOMP] = solve_plane_chan(cx, cy, rPlane);
+ span.color.rgba[ix][GCOMP] = solve_plane_chan(cx, cy, gPlane);
+ span.color.rgba[ix][BCOMP] = solve_plane_chan(cx, cy, bPlane);
+ span.color.rgba[ix][ACOMP] = solve_plane_chan(cx, cy, aPlane);
#endif
#ifdef DO_INDEX
- index[ix] = (GLint) solve_plane(cx, cy, iPlane);
+ span.color.index[ix] = (GLint) solve_plane(cx, cy, iPlane);
#endif
#ifdef DO_SPEC
- spec[ix][RCOMP] = solve_plane_chan(cx, cy, srPlane);
- spec[ix][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
- spec[ix][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
+ span.specular[ix][RCOMP] = solve_plane_chan(cx, cy, srPlane);
+ span.specular[ix][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
+ span.specular[ix][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
#endif
#ifdef DO_TEX
{
const GLfloat invQ = solve_plane_recip(cx, cy, vPlane);
- s[ix] = solve_plane(cx, cy, sPlane) * invQ;
- t[ix] = solve_plane(cx, cy, tPlane) * invQ;
- u[ix] = solve_plane(cx, cy, uPlane) * invQ;
- lambda[ix] = compute_lambda(sPlane, tPlane, invQ,
+ span.texcoords[0][ix][0] = solve_plane(cx, cy, sPlane) * invQ;
+ span.texcoords[0][ix][1] = solve_plane(cx, cy, tPlane) * invQ;
+ span.texcoords[0][ix][2] = solve_plane(cx, cy, uPlane) * invQ;
+ span.lambda[0][ix] = compute_lambda(sPlane, tPlane, invQ,
texWidth, texHeight);
}
#elif defined(DO_MULTITEX)
for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
if (ctx->Texture.Unit[unit]._ReallyEnabled) {
GLfloat invQ = solve_plane_recip(cx, cy, vPlane[unit]);
- s[unit][ix] = solve_plane(cx, cy, sPlane[unit]) * invQ;
- t[unit][ix] = solve_plane(cx, cy, tPlane[unit]) * invQ;
- u[unit][ix] = solve_plane(cx, cy, uPlane[unit]) * invQ;
- lambda[unit][ix] = compute_lambda(sPlane[unit],
- tPlane[unit], invQ, texWidth[unit], texHeight[unit]);
+ span.texcoords[unit][ix][0] = solve_plane(cx, cy, sPlane[unit]) * invQ;
+ span.texcoords[unit][ix][1] = solve_plane(cx, cy, tPlane[unit]) * invQ;
+ span.texcoords[unit][ix][2] = solve_plane(cx, cy, uPlane[unit]) * invQ;
+ span.lambda[unit][ix] = compute_lambda(sPlane[unit],
+ tPlane[unit],
+ invQ,
+ texWidth[unit],
+ texHeight[unit]);
}
}
}
count++;
coverage = compute_coveragef(pMin, pMax, pMid, ix, iy);
}
-
+
if (startX <= ix)
continue;
if (ctx->Texture.Unit[unit]._ReallyEnabled) {
GLint j;
for (j = 0; j < (GLint) n; j++) {
- s[unit][j] = s[unit][j + left];
- t[unit][j] = t[unit][j + left];
- u[unit][j] = u[unit][j + left];
- lambda[unit][j] = lambda[unit][j + left];
+ span.texcoords[unit][j][0] = span.texcoords[unit][j + left][0];
+ span.texcoords[unit][j][1] = span.texcoords[unit][j + left][1];
+ span.texcoords[unit][j][2] = span.texcoords[unit][j + left][2];
+ span.lambda[unit][j] = span.lambda[unit][j + left];
}
}
}
}
# ifdef DO_SPEC
- _mesa_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
- (const GLfloat (*)[MAX_WIDTH]) s,
- (const GLfloat (*)[MAX_WIDTH]) t,
- (const GLfloat (*)[MAX_WIDTH]) u,
- lambda, rgba + left,
- (const GLchan (*)[4]) (spec + left),
- coverageSpan + left,
- GL_POLYGON);
+ _old_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
+ span.texcoords, span.lambda,
+ span.color.rgba + left,
+ span.specular + left,
+ coverageSpan + left,
+ GL_POLYGON);
# else
- _mesa_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
- (const GLfloat (*)[MAX_WIDTH]) s,
- (const GLfloat (*)[MAX_WIDTH]) t,
- (const GLfloat (*)[MAX_WIDTH]) u,
- lambda,
- rgba + left, NULL, coverageSpan + left,
- GL_POLYGON);
+ _old_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
+ span.texcoords, span.lambda,
+ span.color.rgba + left, NULL,
+ coverageSpan + left,
+ GL_POLYGON);
# endif
#elif defined(DO_TEX)
# ifdef DO_SPEC
- _mesa_write_texture_span(ctx, n, left, iy, z + left, fog + left,
- s + left, t + left, u + left,
- lambda + left, rgba + left,
- (const GLchan (*)[4]) (spec + left),
- coverageSpan + left,
- GL_POLYGON);
+ _old_write_texture_span(ctx, n, left, iy, z + left, fog + left,
+ span.texcoords[0] + left,
+ span.lambda[0] + left,
+ span.color.rgba + left,
+ span.specular + left, coverageSpan + left,
+ GL_POLYGON);
# else
- _mesa_write_texture_span(ctx, n, left, iy, z + left, fog + left,
- s + left, t + left,
- u + left, lambda + left,
- rgba + left, NULL,
- coverageSpan + left, GL_POLYGON);
+ _old_write_texture_span(ctx, n, left, iy, z + left, fog + left,
+ span.texcoords[0] + left,
+ span.lambda[0] + left,
+ span.color.rgba + left, NULL,
+ coverageSpan + left, GL_POLYGON);
# endif
#elif defined(DO_RGBA)
- _mesa_write_rgba_span(ctx, n, left, iy, z + left, fog + left,
- rgba + left, coverageSpan + left, GL_POLYGON);
+ _old_write_rgba_span(ctx, n, left, iy, z + left, fog + left,
+ span.color.rgba + left, coverageSpan + left, GL_POLYGON);
#elif defined(DO_INDEX)
- _mesa_write_index_span(ctx, n, left, iy, z + left, fog + left,
- index + left, icoverageSpan + left, GL_POLYGON);
+ _old_write_index_span(ctx, n, left, iy, z + left, fog + left,
+ span.color.index + left,
+ icoverageSpan + left, GL_POLYGON);
#endif
}
}
-#ifdef DO_RGBA
- UNDEFARRAY(rgba); /* mac 32k limitation */
-#endif
-#ifdef DO_SPEC
- UNDEFARRAY(spec);
-#endif
-#if defined(DO_TEX) || defined(DO_MULTITEX)
- UNDEFARRAY(s);
- UNDEFARRAY(t);
- UNDEFARRAY(u);
- UNDEFARRAY(lambda);
-#endif
+
}
-/* $Id: s_context.c,v 1.25 2001/07/28 19:28:49 keithw Exp $ */
+/* $Id: s_context.c,v 1.26 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
static void
_swrast_validate_texture_sample( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj,
- GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
- GLchan rgba[][4] )
+ GLuint n, GLfloat texcoords[][3],
+ const GLfloat lambda[], GLchan rgba[][4] )
{
SWcontext *swrast = SWRAST_CONTEXT(ctx);
_swrast_validate_derived( ctx );
_swrast_choose_texture_sample_func( ctx, texUnit, tObj );
- swrast->TextureSample[texUnit]( ctx, texUnit, tObj, n, s, t, u,
+ swrast->TextureSample[texUnit]( ctx, texUnit, tObj, n, texcoords,
lambda, rgba );
}
-/* $Id: s_context.h,v 1.12 2001/08/14 14:08:44 brianp Exp $ */
+/* $Id: s_context.h,v 1.13 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
*/
typedef void (*TextureSampleFunc)( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj,
- GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
- GLchan rgba[][4] );
+ GLuint n, GLfloat texcoords[][3],
+ const GLfloat lambda[], GLchan rgba[][4] );
GLuint NewState;
GLuint StateChanges;
+
/* Mechanism to allow driver (like X11) to register further
* software rasterization routines.
*/
-/* $Id: s_copypix.c,v 1.25 2001/12/14 02:50:57 brianp Exp $ */
+/* $Id: s_copypix.c,v 1.26 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) {
GLfloat s[MAX_WIDTH], t[MAX_WIDTH], r[MAX_WIDTH], q[MAX_WIDTH];
+ GLfloat texcoord[MAX_WIDTH][3];
GLchan primary_rgba[MAX_WIDTH][4];
GLuint unit;
/* XXX not sure how multitexture is supposed to work here */
MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLchan));
for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+ GLint i;
_mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba,
s, t, r, q);
- _swrast_texture_fragments(ctx, unit, width, s, t, r, NULL,
- (CONST GLchan (*)[4]) primary_rgba,
- rgba);
+ /* this is an ugly work-around. s,t,r has to be copied to
+ texcoords, because the functions need different
+ input. */
+ for (i=0; i<width; i++) {
+ texcoord[i][0] = s[i],
+ texcoord[i][1] = t[i],
+ texcoord[i][2] = r[i];
+ }
+ _old_swrast_texture_fragments( ctx, unit, width, texcoord, NULL,
+ (CONST GLchan (*)[4]) primary_rgba,
+ rgba);
}
}
(const GLchan (*)[4])rgba, desty);
}
else {
- _mesa_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan, rgba,
+ _old_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan, rgba,
NULL, GL_BITMAP );
}
}
if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) {
GLuint unit;
GLchan primary_rgba[MAX_WIDTH][4];
+ GLfloat texcoord[MAX_WIDTH][3];
DEFARRAY(GLfloat, s, MAX_WIDTH); /* mac 32k limitation */
DEFARRAY(GLfloat, t, MAX_WIDTH); /* mac 32k limitation */
DEFARRAY(GLfloat, r, MAX_WIDTH); /* mac 32k limitation */
for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
_mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba,
s, t, r, q);
- _swrast_texture_fragments(ctx, unit, width, s, t, r, NULL,
- (CONST GLchan (*)[4]) primary_rgba,
- rgba);
+ /* this is an ugly work-around. s,t,r has to be copied to
+ texcoords, because the functions need different
+ input. */
+ for (i=0; i<width; i++) {
+ texcoord[i][0] = s[i],
+ texcoord[i][1] = t[i],
+ texcoord[i][2] = r[i];
+ }
+ _old_swrast_texture_fragments( ctx, unit, width, texcoord, NULL,
+ (CONST GLchan (*)[4]) primary_rgba,
+ rgba);
}
UNDEFARRAY(s); /* mac 32k limitation */
(const GLchan (*)[4])rgba, desty);
}
else {
- _mesa_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan, rgba,
+ _old_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan, rgba,
NULL, GL_BITMAP );
}
}
indexes, desty );
}
else {
- _mesa_write_index_span(ctx, width, destx, dy, zspan, fogSpan, indexes,
+ _old_write_index_span(ctx, width, destx, dy, zspan, fogSpan, indexes,
NULL, GL_BITMAP);
}
}
fogSpan, (const GLchan (*)[4])rgba, desty );
}
else {
- _mesa_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan,
+ _old_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan,
(GLchan (*)[4])rgba, NULL, GL_BITMAP);
}
}
zspan, fogSpan, indexes, desty );
}
else {
- _mesa_write_index_span( ctx, width, destx, dy,
+ _old_write_index_span( ctx, width, destx, dy,
zspan, fogSpan, indexes, NULL, GL_BITMAP );
}
}
-/* $Id: s_depth.c,v 1.9 2001/03/19 02:25:36 keithw Exp $ */
+/* $Id: s_depth.c,v 1.10 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Apply depth test to span of fragments. Hardware or software z buffer.
*/
GLuint
-_mesa_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- const GLdepth z[], GLubyte mask[] )
+_old_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], GLubyte mask[] )
{
SWcontext *swrast = SWRAST_CONTEXT(ctx);
if (swrast->Driver.ReadDepthSpan) {
}
}
+/*
+ * Apply depth test to span of fragments. Hardware or software z buffer.
+ */
+GLuint
+_mesa_depth_test_span( GLcontext *ctx, struct sw_span *span)
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+ ASSERT(span->activeMask & SPAN_Z);
+ ASSERT(span->filledMask == GL_TRUE);
+ ASSERT(span->filledDepth == GL_TRUE);
+ SW_SPAN_SET_FLAG(span->testedDepth);
+
+ if (swrast->Driver.ReadDepthSpan) {
+ /* hardware-based depth buffer */
+ GLdepth zbuffer[MAX_WIDTH];
+ GLuint passed;
+ (*swrast->Driver.ReadDepthSpan)(ctx, span->end, span->x, span->y, zbuffer);
+ passed = depth_test_span32(ctx, span->end, span->x, span->y,
+ zbuffer, span->depth, span->mask);
+ ASSERT(swrast->Driver.WriteDepthSpan);
+ (*swrast->Driver.WriteDepthSpan)(ctx, span->end, span->x, span->y, zbuffer, span->mask);
+ if (passed < span->end)
+ span->write_all = GL_FALSE;
+ return passed;
+ }
+ else {
+ GLuint passed;
+ /* software depth buffer */
+ if (ctx->Visual.depthBits <= 16) {
+ GLushort *zptr = (GLushort *) Z_ADDRESS16(ctx, span->x, span->y);
+ passed = depth_test_span16(ctx, span->end, span->x, span->y, zptr, span->depth, span->mask);
+ }
+ else {
+ GLuint *zptr = (GLuint *) Z_ADDRESS32(ctx, span->x, span->y);
+ passed = depth_test_span32(ctx, span->end, span->x, span->y, zptr, span->depth, span->mask);
+ }
+ if (passed < span->end)
+ span->write_all = GL_FALSE;
+ return passed;
+ }
+}
+
-/* $Id: s_depth.h,v 1.3 2001/03/12 00:48:41 gareth Exp $ */
+/* $Id: s_depth.h,v 1.4 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
extern GLuint
-_mesa_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- const GLdepth z[], GLubyte mask[] );
+_old_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], GLubyte mask[] );
+extern GLuint
+_mesa_depth_test_span( GLcontext *ctx, struct sw_span *span);
extern void
_mesa_depth_test_pixels( GLcontext *ctx,
-/* $Id: s_drawpix.c,v 1.22 2001/06/26 21:15:36 brianp Exp $ */
+/* $Id: s_drawpix.c,v 1.23 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
indexes, desty);
}
else {
- _mesa_write_index_span(ctx, drawWidth, x, y, zspan, fogSpan, indexes,
+ _old_write_index_span(ctx, drawWidth, x, y, zspan, fogSpan, indexes,
NULL, GL_BITMAP);
}
}
GLint i;
for (i = 0; i < width; i++)
zspan[i] = zptr[i];
- _mesa_write_rgba_span(ctx, width, x, y, zspan, 0, rgba,
+ _old_write_rgba_span(ctx, width, x, y, zspan, 0, rgba,
NULL, GL_BITMAP);
}
}
const GLuint *zptr = (const GLuint *)
_mesa_image_address(&ctx->Unpack, pixels, width, height,
GL_DEPTH_COMPONENT, type, 0, row, 0);
- _mesa_write_rgba_span(ctx, width, x, y, zptr, 0, rgba,
+ _old_write_rgba_span(ctx, width, x, y, zptr, 0, rgba,
NULL, GL_BITMAP);
}
}
(const GLchan (*)[4]) rgba, desty);
}
else {
- _mesa_write_rgba_span(ctx, width, x, y, zspan, 0,
+ _old_write_rgba_span(ctx, width, x, y, zspan, 0,
rgba, NULL, GL_BITMAP);
}
}
ispan, GL_BITMAP);
}
else {
- _mesa_write_index_span(ctx, width, x, y, zspan, 0,
+ _old_write_index_span(ctx, width, x, y, zspan, 0,
ispan, NULL, GL_BITMAP);
}
}
if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) {
GLchan primary_rgba[MAX_WIDTH][4];
GLuint unit;
+ GLfloat texcoord[MAX_WIDTH][3];
DEFARRAY(GLfloat, s, MAX_WIDTH); /* mac 32k limitation */
DEFARRAY(GLfloat, t, MAX_WIDTH);
DEFARRAY(GLfloat, r, MAX_WIDTH);
for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
if (ctx->Texture.Unit[unit]._ReallyEnabled) {
+ GLint i;
_mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba,
s, t, r, q);
- _swrast_texture_fragments(ctx, unit, width, s, t, r, NULL,
- (CONST GLchan (*)[4]) primary_rgba,
- rgba);
+ /* this is an ugly work-around. s,t,r has to be
+ copied to texcoords, because the functions need
+ different input. */
+ for (i=0; i<width; i++) {
+ texcoord[i][0] = s[i],
+ texcoord[i][1] = t[i],
+ texcoord[i][2] = r[i];
+ }
+ _old_swrast_texture_fragments( ctx, unit, width,
+ texcoord, NULL,
+ (CONST GLchan (*)[4]) primary_rgba,
+ rgba);
}
}
UNDEFARRAY(s); /* mac 32k limitation */
(CONST GLchan (*)[4]) rgba, desty);
}
else {
- _mesa_write_rgba_span(ctx, (GLuint) width, x, y, zspan, fogSpan,
+ _old_write_rgba_span(ctx, (GLuint) width, x, y, zspan, fogSpan,
rgba, NULL, GL_BITMAP);
}
}
-/* $Id: s_fog.c,v 1.14 2001/09/19 20:30:44 kschultz Exp $ */
+/* $Id: s_fog.c,v 1.15 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
+/*
+ * Apply fog to a span of RGBA pixels.
+ * Input: ctx -
+ * span - where span->fog and span->fogStep have to be set.
+ * red, green, blue, alpha - pixel colors
+ * Output: red, green, blue, alpha - fogged pixel colors
+ */
+void
+_mesa_fog_rgba_pixels( const GLcontext *ctx, struct sw_span *span,
+ GLchan rgba[][4] )
+{
+ GLuint i;
+ GLfloat fog = span->fog, Dfog = span->fogStep;
+ GLchan rFog, gFog, bFog;
+
+ ASSERT(ctx->Fog.Enabled);
+ ASSERT(span->activeMask & SPAN_FOG);
+ ASSERT(span->filledColor == GL_TRUE);
+
+ UNCLAMPED_FLOAT_TO_CHAN(rFog, ctx->Fog.Color[RCOMP]);
+ UNCLAMPED_FLOAT_TO_CHAN(gFog, ctx->Fog.Color[GCOMP]);
+ UNCLAMPED_FLOAT_TO_CHAN(bFog, ctx->Fog.Color[BCOMP]);
+
+ for (i = 0; i < span->end; i++) {
+ const GLfloat one_min_fog = 1.0F - fog;
+ rgba[i][RCOMP] = (GLchan) (fog * rgba[i][RCOMP] + one_min_fog * rFog);
+ rgba[i][GCOMP] = (GLchan) (fog * rgba[i][GCOMP] + one_min_fog * gFog);
+ rgba[i][BCOMP] = (GLchan) (fog * rgba[i][BCOMP] + one_min_fog * bFog);
+ fog += Dfog;
+ }
+}
+
/*
* Apply fog to an array of RGBA pixels.
* Input: n - number of pixels
* Output: red, green, blue, alpha - fogged pixel colors
*/
void
-_mesa_fog_rgba_pixels( const GLcontext *ctx,
+_old_fog_rgba_pixels( const GLcontext *ctx,
GLuint n,
const GLfloat fog[],
GLchan rgba[][4] )
}
+/*
+ * Apply fog to a span of color index pixels.
+ * Input: ctx -
+ * span - where span->fog and span->fogStep have to be set.
+ * index - pixel color indexes
+ * Output: index - fogged pixel color indexes
+ */
+void
+_mesa_fog_ci_pixels( const GLcontext *ctx, struct sw_span *span,
+ GLuint index[] )
+{
+ GLuint idx = (GLuint) ctx->Fog.Index;
+ GLuint i;
+ GLfloat fog = span->fog, Dfog = span->fogStep;
+
+ ASSERT(ctx->Fog.Enabled);
+ ASSERT(span->activeMask & SPAN_FOG);
+ ASSERT(span->filledColor == GL_TRUE);
+
+ for (i = 0; i < span->end; i++) {
+ const GLfloat f = CLAMP(fog, 0.0F, 1.0F);
+ index[i] = (GLuint) ((GLfloat) index[i] + (1.0F - f) * idx);
+ fog += Dfog;
+ }
+}
/*
* Apply fog to an array of color index pixels.
* Output: index - fogged pixel color indexes
*/
void
-_mesa_fog_ci_pixels( const GLcontext *ctx,
+_old_fog_ci_pixels( const GLcontext *ctx,
GLuint n, const GLfloat fog[], GLuint index[] )
{
GLuint idx = (GLuint) ctx->Fog.Index;
}
+/*
+ * Apply fog to a span of RGBA pixels.
+ * Input: ctx -
+ * span - where span->depth has to be filled.
+ * red, green, blue, alpha - pixel colors
+ * Output: red, green, blue, alpha - fogged pixel colors
+ */
+void
+_mesa_depth_fog_rgba_pixels(const GLcontext *ctx, struct sw_span *span,
+ GLchan rgba[][4])
+{
+ GLfloat fogFact[PB_SIZE];
+
+ ASSERT(ctx->Fog.Enabled);
+ ASSERT(span->activeMask & SPAN_Z);
+ ASSERT(span->end <= PB_SIZE);
+ ASSERT(span->filledDepth == GL_TRUE);
+ ASSERT(span->filledColor == GL_TRUE);
+
+ compute_fog_factors_from_z(ctx, span->end, span->depth, fogFact );
+ _old_fog_rgba_pixels( ctx, span->end, fogFact, rgba );
+}
+
/*
* Apply fog to an array of RGBA pixels.
* Input: n - number of pixels
* Output: red, green, blue, alpha - fogged pixel colors
*/
void
-_mesa_depth_fog_rgba_pixels( const GLcontext *ctx,
+_old_depth_fog_rgba_pixels( const GLcontext *ctx,
GLuint n, const GLdepth z[], GLchan rgba[][4] )
{
GLfloat fogFact[PB_SIZE];
ASSERT(n <= PB_SIZE);
compute_fog_factors_from_z( ctx, n, z, fogFact );
- _mesa_fog_rgba_pixels( ctx, n, fogFact, rgba );
+ _old_fog_rgba_pixels( ctx, n, fogFact, rgba );
+}
+
+
+/*
+ * Apply fog to a span of color index pixels.
+ * Input: ctx -
+ * span - where span->depth has to be filled.
+ * index - pixel color indexes
+ * Output: index - fogged pixel color indexes
+ */
+void
+_mesa_depth_fog_ci_pixels( const GLcontext *ctx, struct sw_span *span,
+ GLuint index[] )
+{
+ GLfloat fogFact[PB_SIZE];
+
+ ASSERT(ctx->Fog.Enabled);
+ ASSERT(span->activeMask & SPAN_Z);
+ ASSERT(span->end <= PB_SIZE);
+ ASSERT(span->filledDepth == GL_TRUE);
+ ASSERT(span->filledColor == GL_TRUE);
+
+ compute_fog_factors_from_z(ctx, span->end, span->depth, fogFact );
+ _old_fog_ci_pixels( ctx, span->end, fogFact, index );
}
* Output: index - fogged pixel color indexes
*/
void
-_mesa_depth_fog_ci_pixels( const GLcontext *ctx,
+_old_depth_fog_ci_pixels( const GLcontext *ctx,
GLuint n, const GLdepth z[], GLuint index[] )
{
GLfloat fogFact[PB_SIZE];
ASSERT(n <= PB_SIZE);
compute_fog_factors_from_z( ctx, n, z, fogFact );
- _mesa_fog_ci_pixels( ctx, n, fogFact, index );
+ _old_fog_ci_pixels( ctx, n, fogFact, index );
}
-/* $Id: s_fog.h,v 1.5 2001/06/18 23:55:18 brianp Exp $ */
+/* $Id: s_fog.h,v 1.6 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
extern void
-_mesa_fog_rgba_pixels( const GLcontext *ctx,
+_old_fog_rgba_pixels( const GLcontext *ctx,
GLuint n, const GLfloat fog[],
GLchan rgba[][4] );
+extern void
+_mesa_fog_rgba_pixels( const GLcontext *ctx, struct sw_span *span,
+ GLchan rgba[][4]);
extern void
-_mesa_fog_ci_pixels( const GLcontext *ctx,
- GLuint n, const GLfloat fog[], GLuint indx[] );
+_mesa_fog_ci_pixels( const GLcontext *ctx, struct sw_span *span,
+ GLuint indx[]);
+extern void
+_old_fog_ci_pixels( const GLcontext *ctx,
+ GLuint n, const GLfloat fog[],
+ GLuint indx[] );
extern void
_mesa_win_fog_coords_from_z( const GLcontext *ctx,
GLfloat fogcoord[] );
extern void
-_mesa_depth_fog_rgba_pixels( const GLcontext *ctx,
+_mesa_depth_fog_rgba_pixels( const GLcontext *ctx, struct sw_span *span,
+ GLchan rgba[][4] );
+extern void
+_old_depth_fog_rgba_pixels( const GLcontext *ctx,
GLuint n, const GLdepth z[], GLchan rgba[][4] );
extern void
-_mesa_depth_fog_ci_pixels( const GLcontext *ctx,
- GLuint n, const GLdepth z[], GLuint index[] );
-
+_mesa_depth_fog_ci_pixels( const GLcontext *ctx, struct sw_span *span,
+ GLuint index[] );
+extern void
+_old_depth_fog_ci_pixels( const GLcontext *ctx,
+ GLuint n, const GLdepth z[], GLuint index[] );
#endif
-/* $Id: s_span.c,v 1.19 2001/11/19 01:18:28 brianp Exp $ */
+/* $Id: s_span.c,v 1.20 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
#include "s_stencil.h"
#include "s_texture.h"
+INLINE
+static void SET_MASK_TO_ONE(struct sw_span *span) {
+ SW_SPAN_SET_FLAG(span->filledMask);
+ /* init mask to 1's (all pixels are to be written) */
+ MEMSET(span->mask, 1, span->end);
+}
/*
* Apply the current polygon stipple pattern to a span of pixels.
*/
static void
-stipple_polygon_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+old_stipple_polygon_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
GLubyte mask[] )
{
const GLuint highbit = 0x80000000;
}
}
+/*
+ * Apply the current polygon stipple pattern to a span of pixels.
+ */
+static void
+stipple_polygon_span( GLcontext *ctx, struct sw_span *span)
+{
+ const GLuint highbit = 0x80000000;
+ GLuint i, m, stipple;
+
+ ASSERT (span->filledMask == GL_TRUE);
+
+ stipple = ctx->PolygonStipple[span->y % 32];
+ m = highbit >> (GLuint) (span->x % 32);
+
+ for (i = 0; i < span->end; i++) {
+ if ((m & stipple) == 0) {
+ span->mask[i] = 0;
+ }
+ m = m >> 1;
+ if (m == 0) {
+ m = highbit;
+ }
+ }
+ span->write_all = GL_FALSE;
+}
+
/*
* 0 = all pixels clipped
*/
static GLuint
-clip_span( GLcontext *ctx, GLint n, GLint x, GLint y, GLubyte mask[] )
+old_clip_span( GLcontext *ctx, GLint n, GLint x, GLint y, GLubyte mask[] )
{
/* Clip to top and bottom */
if (y < 0 || y >= ctx->DrawBuffer->Height) {
}
+/*
+ * Clip a pixel span to the current buffer/window boundaries.
+ * Return: GL_TRUE some pixel still visible
+ * GL_FALSE nothing visible
+ */
+static GLuint
+clip_span( GLcontext *ctx, struct sw_span *span)
+{
+ GLint x = span->x, y = span->y, n = span->end;
+
+ ASSERT (span->filledMask == GL_TRUE);
+
+ /* Clip to top and bottom */
+ if (y < 0 || y >= ctx->DrawBuffer->Height) {
+ span->end = 0;
+ return GL_FALSE;
+ }
+
+ /* Clip to the left */
+ if (x < 0) {
+ if (x + n <= 0) {
+ /* completely off left side */
+ span->end = 0;
+ return GL_FALSE;
+ }
+ else {
+ /* partially off left side */
+ span->write_all = GL_FALSE;
+ BZERO(span->mask, -x * sizeof(GLubyte));
+ return GL_TRUE;
+ }
+ }
+
+ /* Clip to right */
+ if (x + n > ctx->DrawBuffer->Width) {
+ if (x >= ctx->DrawBuffer->Width) {
+ /* completely off right side */
+ span->end = 0;
+ return GL_FALSE;
+ }
+ else {
+ /* partially off right side */
+ span->end = ctx->DrawBuffer->Width - x;
+ return GL_TRUE;
+ }
+ }
+
+ return GL_TRUE;
+}
+
+
/*
* Draw to more than one color buffer (or none).
}
+/*
+ * Draw to more than one RGBA color buffer (or none).
+ */
+static void
+multi_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+ const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+ GLuint bufferBit;
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+ if (ctx->Color.DrawBuffer == GL_NONE)
+ return;
+
+ /* loop over four possible dest color buffers */
+ for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
+ if (bufferBit & ctx->Color.DrawDestMask) {
+ GLchan rgbaTmp[MAX_WIDTH][4];
+ ASSERT(n < MAX_WIDTH);
+
+ if (bufferBit == FRONT_LEFT_BIT) {
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
+ ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontLeftAlpha;
+ }
+ else if (bufferBit == FRONT_RIGHT_BIT) {
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
+ ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontRightAlpha;
+ }
+ else if (bufferBit == BACK_LEFT_BIT) {
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
+ ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackLeftAlpha;
+ }
+ else {
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
+ ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackRightAlpha;
+ }
+
+ /* make copy of incoming colors */
+ MEMCPY( rgbaTmp, rgba, 4 * n * sizeof(GLchan) );
+
+ if (ctx->Color.ColorLogicOpEnabled) {
+ _mesa_logicop_rgba_span( ctx, n, x, y, rgbaTmp, mask );
+ }
+ else if (ctx->Color.BlendEnabled) {
+ _mesa_blend_span( ctx, n, x, y, rgbaTmp, mask );
+ }
+ if (colorMask == 0x0) {
+ break;
+ }
+ else if (colorMask != 0xffffffff) {
+ _mesa_mask_rgba_span( ctx, n, x, y, rgbaTmp );
+ }
+
+ (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y,
+ (const GLchan (*)[4]) rgbaTmp, mask );
+ if (swrast->_RasterMask & ALPHABUF_BIT) {
+ _mesa_write_alpha_span( ctx, n, x, y,
+ (const GLchan (*)[4])rgbaTmp, mask );
+ }
+ }
+ }
+
+ /* restore default dest buffer */
+ (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer );
+}
+
+
/*
* Write a horizontal span of color index pixels to the frame buffer.
* primitive - either GL_POINT, GL_LINE, GL_POLYGON, or GL_BITMAP
*/
void
-_mesa_write_index_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+_old_write_index_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
const GLdepth z[], const GLfloat fog[],
GLuint indexIn[], const GLint coverage[],
GLenum primitive )
MEMSET(mask, 1, n);
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if ((n = clip_span(ctx,n,x,y,mask)) == 0) {
+ if ((n = old_clip_span(ctx,n,x,y,mask)) == 0) {
return;
}
}
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+ if ((n = _old_scissor_span( ctx, n, x, y, mask )) == 0) {
return;
}
}
/* Polygon Stippling */
if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
- stipple_polygon_span( ctx, n, x, y, mask );
+ old_stipple_polygon_span( ctx, n, x, y, mask );
}
if (ctx->Stencil.Enabled) {
/* first stencil test */
- if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+ if (_old_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
return;
}
}
else if (ctx->Depth.Test) {
/* regular depth testing */
- if (_mesa_depth_test_span( ctx, n, x, y, z, mask ) == 0)
+ if (_old_depth_test_span( ctx, n, x, y, z, mask ) == 0)
return;
}
/* Per-pixel fog */
if (ctx->Fog.Enabled) {
if (fog && !swrast->_PreferPixelFog)
- _mesa_fog_ci_pixels( ctx, n, fog, index );
+ _old_fog_ci_pixels( ctx, n, fog, index );
else
- _mesa_depth_fog_ci_pixels( ctx, n, z, index );
+ _old_depth_fog_ci_pixels( ctx, n, z, index );
}
/* Antialias coverage application */
}
-
-
+/*
+ * Apply fragment processing to a span of RGBA fragments.
+ * Input:
+ * n - number of fragments in the span
+ * x,y - location of first (left) fragment
+ * fog - array of fog factor values in [0,1]
+ */
void
-_mesa_write_monoindex_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- const GLdepth z[], const GLfloat fog[],
- GLuint index, const GLint coverage[],
- GLenum primitive )
+_old_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], const GLfloat fog[],
+ GLchan rgbaIn[][4], const GLfloat coverage[],
+ GLenum primitive )
{
- SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ const GLuint modBits = FOG_BIT | BLEND_BIT | MASKING_BIT |
+ LOGIC_OP_BIT | TEXTURE_BIT;
GLubyte mask[MAX_WIDTH];
- GLuint i;
+ GLboolean write_all = GL_TRUE;
+ GLchan rgbaBackup[MAX_WIDTH][4];
+ GLchan (*rgba)[4];
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
/* init mask to 1's (all pixels are to be written) */
MEMSET(mask, 1, n);
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if ((n = clip_span( ctx, n, x, y, mask)) == 0) {
+ if ((n = old_clip_span( ctx,n,x,y,mask)) == 0) {
+ return;
+ }
+ if (mask[0] == 0)
+ write_all = GL_FALSE;
+ }
+
+ if ((primitive==GL_BITMAP && (swrast->_RasterMask & modBits))
+ || (swrast->_RasterMask & MULTI_DRAW_BIT)) {
+ /* must make a copy of the colors since they may be modified */
+ MEMCPY( rgbaBackup, rgbaIn, 4 * n * sizeof(GLchan) );
+ rgba = rgbaBackup;
+ }
+ else {
+ rgba = rgbaIn;
+ }
+
+ /* Do the scissor test */
+ if (ctx->Scissor.Enabled) {
+ if ((n = _old_scissor_span( ctx, n, x, y, mask )) == 0) {
+ return;
+ }
+ if (mask[0] == 0)
+ write_all = GL_FALSE;
+ }
+
+ /* Polygon Stippling */
+ if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+ old_stipple_polygon_span( ctx, n, x, y, mask );
+ write_all = GL_FALSE;
+ }
+
+ /* Do the alpha test */
+ if (ctx->Color.AlphaEnabled) {
+ if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4]) rgba, mask ) == 0) {
+ return;
+ }
+ write_all = GL_FALSE;
+ }
+
+ if (ctx->Stencil.Enabled) {
+ /* first stencil test */
+ if (_old_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
return;
}
+ write_all = GL_FALSE;
+ }
+ else if (ctx->Depth.Test) {
+ /* regular depth testing */
+ GLuint m = _old_depth_test_span( ctx, n, x, y, z, mask );
+ if (m == 0) {
+ return;
+ }
+ if (m < n) {
+ write_all = GL_FALSE;
+ }
+ }
+
+ /* if we get here, something passed the depth test */
+ ctx->OcclusionResult = GL_TRUE;
+
+ /* Per-pixel fog */
+ if (ctx->Fog.Enabled) {
+ if (fog && !swrast->_PreferPixelFog)
+ _old_fog_rgba_pixels( ctx, n, fog, rgba );
+ else
+ _old_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ }
+
+ /* Antialias coverage application */
+ if (coverage) {
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+ }
}
+ if (swrast->_RasterMask & MULTI_DRAW_BIT) {
+ multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
+ }
+ else {
+ /* normal: write to exactly one buffer */
+ /* logic op or blending */
+ const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+
+ if (ctx->Color.ColorLogicOpEnabled) {
+ _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+ }
+ else if (ctx->Color.BlendEnabled) {
+ _mesa_blend_span( ctx, n, x, y, rgba, mask );
+ }
+
+ /* Color component masking */
+ if (colorMask == 0x0) {
+ return;
+ }
+ else if (colorMask != 0xffffffff) {
+ _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+ }
+
+ /* write pixels */
+ (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y,
+ (const GLchan (*)[4]) rgba,
+ write_all ? ((const GLubyte *) NULL) : mask );
+
+ if (swrast->_RasterMask & ALPHABUF_BIT) {
+ _mesa_write_alpha_span( ctx, n, x, y,
+ (const GLchan (*)[4]) rgba,
+ write_all ? ((const GLubyte *) NULL) : mask );
+ }
+ }
+}
+
+
+/*
+ * Write a horizontal span of color index pixels to the frame buffer.
+ * Stenciling, Depth-testing, etc. are done as needed.
+ * Input: primitive - either GL_POINT, GL_LINE, GL_POLYGON, or GL_BITMAP
+ */
+void
+_mesa_write_index_span( GLcontext *ctx, struct sw_span *span,
+ GLenum primitive )
+{
+ const GLuint modBits = FOG_BIT | BLEND_BIT | MASKING_BIT | LOGIC_OP_BIT;
+ GLuint indexBackup[MAX_WIDTH];
+ GLuint *index; /* points to indexIn or indexBackup */
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+
+ SET_MASK_TO_ONE(span);
+
+ if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if (clip_span(ctx,span) == GL_FALSE) {
+ return;
+ }
+ }
+
+ if ((primitive==GL_BITMAP && (swrast->_RasterMask & modBits))
+ || (swrast->_RasterMask & MULTI_DRAW_BIT)) {
+ /* Make copy of color indexes */
+ MEMCPY( indexBackup, span->color.index, span->end * sizeof(GLuint) );
+ index = indexBackup;
+ }
+ else {
+ index = span->color.index;
+ }
+
+
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+ if (_mesa_scissor_span( ctx, span ) == GL_FALSE) {
return;
}
}
/* Polygon Stippling */
if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
- stipple_polygon_span( ctx, n, x, y, mask );
+ stipple_polygon_span(ctx, span);
+ }
+
+
+ /* I have to think where to put this!! */
+ if (span->activeMask & SPAN_Z) {
+ SW_SPAN_SET_FLAG(span->filledDepth);
+
+ if (ctx->Visual.depthBits <= 16) {
+ GLuint i;
+ GLfixed zval = span->z;
+ for (i = 0; i < span->end; i++) {
+ span->depth[i] = FixedToInt(zval);
+ zval += span->zStep;
+ }
+ }
+ else {
+ /* Deep Z buffer, no fixed->int shift */
+ GLuint i;
+ GLfixed zval = span->z;
+ for (i = 0; i < span->end; i++) {
+ span->depth[i] = zval;
+ zval += span->zStep;
+ }
+ }
}
+
if (ctx->Stencil.Enabled) {
/* first stencil test */
- if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+ if (_mesa_stencil_and_ztest_span(ctx, span) == GL_FALSE)
return;
+ }
+ else if (ctx->Depth.Test) {
+ /* regular depth testing */
+ if (_mesa_depth_test_span(ctx, span) == 0)
+ return;
+ }
+
+ /* if we get here, something passed the depth test */
+ ctx->OcclusionResult = GL_TRUE;
+
+ if (ctx->Color.DrawBuffer == GL_NONE) {
+ /* write no pixels */
+ return;
+ }
+
+ if (ctx->Fog.Enabled) {
+ /* Is this the right 'if' ?? */
+ if ((span->activeMask & SPAN_FOG) && !swrast->_PreferPixelFog)
+ _mesa_fog_ci_pixels( ctx, span, index);
+ else
+ _mesa_depth_fog_ci_pixels( ctx, span, index);
+ }
+
+ /* Antialias coverage application */
+#if 0
+ if (span->coverage) {
+ GLuint i;
+ for (i = 0; i < span->end; i++) {
+ ASSERT(span->coverage[i] < 16);
+ index[i] = (index[i] & ~0xf) | span->coverage[i];
+ }
+ }
+#endif
+
+ if (swrast->_RasterMask & MULTI_DRAW_BIT) {
+ /* draw to zero or two or more buffers */
+ multi_write_index_span( ctx, span->end, span->x, span->y,
+ index, span->mask );
+ }
+ else {
+ /* normal situation: draw to exactly one buffer */
+ if (ctx->Color.IndexLogicOpEnabled) {
+ _mesa_logicop_ci_span( ctx, span->end, span->x, span->y,
+ index, span->mask );
+ }
+
+ if (ctx->Color.IndexMask == 0) {
+ return;
+ }
+ else if (ctx->Color.IndexMask != 0xffffffff) {
+ _mesa_mask_index_span( ctx, span->end, span->x, span->y, index );
+ }
+
+ /* write pixels */
+ (*swrast->Driver.WriteCI32Span)( ctx, span->end, span->x,
+ span->y, index, span->mask );
+ }
+}
+
+
+
+
+void
+_mesa_write_monoindex_span( GLcontext *ctx, struct sw_span *span,
+ GLuint index, GLenum primitive )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ GLuint i;
+
+
+ SET_MASK_TO_ONE(span);
+
+ if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+ if (clip_span(ctx,span) == GL_FALSE) {
+ return;
+ }
+ }
+
+ /* Do the scissor test */
+ if (ctx->Scissor.Enabled) {
+ if (_mesa_scissor_span( ctx, span ) == GL_FALSE) {
+ return;
+ }
+ }
+
+ /* Polygon Stippling */
+ if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+ stipple_polygon_span( ctx, span);
+ }
+
+
+ /* I have to think where to put this!! */
+ if (span->activeMask & SPAN_Z) {
+ SW_SPAN_SET_FLAG(span->filledDepth);
+
+ if (ctx->Visual.depthBits <= 16) {
+ GLuint i;
+ GLfixed zval = span->z;
+ for (i = 0; i < span->end; i++) {
+ span->depth[i] = FixedToInt(zval);
+ zval += span->zStep;
+ }
+ }
+ else {
+ /* Deep Z buffer, no fixed->int shift */
+ GLuint i;
+ GLfixed zval = span->z;
+ for (i = 0; i < span->end; i++) {
+ span->depth[i] = zval;
+ zval += span->zStep;
+ }
}
}
+
+ if (ctx->Stencil.Enabled) {
+ /* first stencil test */
+ if (_mesa_stencil_and_ztest_span(ctx, span) == GL_FALSE)
+ return;
+ }
else if (ctx->Depth.Test) {
/* regular depth testing */
- if (_mesa_depth_test_span( ctx, n, x, y, z, mask ) == 0)
+ if (_mesa_depth_test_span( ctx, span) == 0)
return;
}
if (ctx->Fog.Enabled
|| ctx->Color.IndexLogicOpEnabled
|| ctx->Color.IndexMask != 0xffffffff
- || coverage) {
+#if 0
+ || span->coverage) {
+#else
+ ) {
+#endif
/* different index per pixel */
GLuint indexes[MAX_WIDTH];
- for (i = 0; i < n; i++) {
+ for (i = 0; i < span->end; i++) {
indexes[i] = index;
}
if (ctx->Fog.Enabled) {
- if (fog && !swrast->_PreferPixelFog)
- _mesa_fog_ci_pixels( ctx, n, fog, indexes );
+ /* Is this the right 'if' ?? */
+ if ((span->activeMask & SPAN_FOG) && !swrast->_PreferPixelFog)
+ _mesa_fog_ci_pixels( ctx, span, indexes );
else
- _mesa_depth_fog_ci_pixels( ctx, n, z, indexes );
+ _mesa_depth_fog_ci_pixels( ctx, span, indexes );
}
/* Antialias coverage application */
- if (coverage) {
+#if 0
+ if (span->coverage) {
GLuint i;
- for (i = 0; i < n; i++) {
- ASSERT(coverage[i] < 16);
- indexes[i] = (indexes[i] & ~0xf) | coverage[i];
+ for (i = 0; i < span->end; i++) {
+ ASSERT(span->coverage[i] < 16);
+ indexes[i] = (indexes[i] & ~0xf) | span->coverage[i];
}
}
+#endif
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
/* draw to zero or two or more buffers */
- multi_write_index_span( ctx, n, x, y, indexes, mask );
+ multi_write_index_span( ctx, span->end, span->x, span->y, indexes, span->mask );
}
else {
/* normal situation: draw to exactly one buffer */
if (ctx->Color.IndexLogicOpEnabled) {
- _mesa_logicop_ci_span( ctx, n, x, y, indexes, mask );
+ _mesa_logicop_ci_span( ctx, span->end, span->x, span->y, indexes, span->mask );
}
if (ctx->Color.IndexMask == 0) {
return;
}
else if (ctx->Color.IndexMask != 0xffffffff) {
- _mesa_mask_index_span( ctx, n, x, y, indexes );
+ _mesa_mask_index_span( ctx, span->end, span->x, span->y, indexes );
}
- (*swrast->Driver.WriteCI32Span)( ctx, n, x, y, indexes, mask );
+ (*swrast->Driver.WriteCI32Span)( ctx, span->end, span->x, span->y, indexes, span->mask );
}
}
else {
ASSERT(!ctx->Color.IndexLogicOpEnabled);
ASSERT(ctx->Color.IndexMask == 0xffffffff);
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
- /* draw to zero or two or more buffers */
- GLuint indexes[MAX_WIDTH];
- for (i = 0; i < n; i++)
- indexes[i] = index;
- multi_write_index_span( ctx, n, x, y, indexes, mask );
- }
- else {
- /* normal situation: draw to exactly one buffer */
- (*swrast->Driver.WriteMonoCISpan)( ctx, n, x, y, index, mask );
- }
- }
-}
-
-
-
-/*
- * Draw to more than one RGBA color buffer (or none).
- */
-static void
-multi_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- CONST GLchan rgba[][4], const GLubyte mask[] )
-{
- const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
- GLuint bufferBit;
- SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
- if (ctx->Color.DrawBuffer == GL_NONE)
- return;
-
- /* loop over four possible dest color buffers */
- for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
- if (bufferBit & ctx->Color.DrawDestMask) {
- GLchan rgbaTmp[MAX_WIDTH][4];
- ASSERT(n < MAX_WIDTH);
-
- if (bufferBit == FRONT_LEFT_BIT) {
- (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
- ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontLeftAlpha;
- }
- else if (bufferBit == FRONT_RIGHT_BIT) {
- (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
- ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontRightAlpha;
- }
- else if (bufferBit == BACK_LEFT_BIT) {
- (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
- ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackLeftAlpha;
- }
- else {
- (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
- ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackRightAlpha;
- }
-
- /* make copy of incoming colors */
- MEMCPY( rgbaTmp, rgba, 4 * n * sizeof(GLchan) );
-
- if (ctx->Color.ColorLogicOpEnabled) {
- _mesa_logicop_rgba_span( ctx, n, x, y, rgbaTmp, mask );
- }
- else if (ctx->Color.BlendEnabled) {
- _mesa_blend_span( ctx, n, x, y, rgbaTmp, mask );
- }
- if (colorMask == 0x0) {
- break;
- }
- else if (colorMask != 0xffffffff) {
- _mesa_mask_rgba_span( ctx, n, x, y, rgbaTmp );
- }
-
- (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y,
- (const GLchan (*)[4]) rgbaTmp, mask );
- if (swrast->_RasterMask & ALPHABUF_BIT) {
- _mesa_write_alpha_span( ctx, n, x, y,
- (const GLchan (*)[4])rgbaTmp, mask );
- }
+ /* draw to zero or two or more buffers */
+ GLuint indexes[MAX_WIDTH];
+ for (i = 0; i < span->end; i++)
+ indexes[i] = index;
+ multi_write_index_span( ctx, span->end, span->x, span->y, indexes, span->mask );
+ }
+ else {
+ /* normal situation: draw to exactly one buffer */
+ (*swrast->Driver.WriteMonoCISpan)( ctx, span->end, span->x, span->y, index, span->mask );
}
}
-
- /* restore default dest buffer */
- (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer );
}
/*
* Apply fragment processing to a span of RGBA fragments.
* Input:
- * n - number of fragments in the span
- * x,y - location of first (left) fragment
- * fog - array of fog factor values in [0,1]
*/
void
-_mesa_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- const GLdepth z[], const GLfloat fog[],
- GLchan rgbaIn[][4], const GLfloat coverage[],
+_mesa_write_rgba_span( GLcontext *ctx, struct sw_span *span,
GLenum primitive )
{
const GLuint modBits = FOG_BIT | BLEND_BIT | MASKING_BIT |
LOGIC_OP_BIT | TEXTURE_BIT;
- GLubyte mask[MAX_WIDTH];
- GLboolean write_all = GL_TRUE;
GLchan rgbaBackup[MAX_WIDTH][4];
GLchan (*rgba)[4];
SWcontext *swrast = SWRAST_CONTEXT(ctx);
- /* init mask to 1's (all pixels are to be written) */
- MEMSET(mask, 1, n);
+
+ SET_MASK_TO_ONE(span);
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if ((n = clip_span( ctx,n,x,y,mask)) == 0) {
+ if (clip_span( ctx,span ) == GL_FALSE) {
return;
}
- if (mask[0] == 0)
- write_all = GL_FALSE;
}
- if ((primitive==GL_BITMAP && (swrast->_RasterMask & modBits))
- || (swrast->_RasterMask & MULTI_DRAW_BIT)) {
- /* must make a copy of the colors since they may be modified */
- MEMCPY( rgbaBackup, rgbaIn, 4 * n * sizeof(GLchan) );
- rgba = rgbaBackup;
- }
- else {
- rgba = rgbaIn;
- }
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+ if (_mesa_scissor_span( ctx, span ) == GL_FALSE) {
return;
}
- if (mask[0] == 0)
- write_all = GL_FALSE;
}
+
/* Polygon Stippling */
if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
- stipple_polygon_span( ctx, n, x, y, mask );
- write_all = GL_FALSE;
+ stipple_polygon_span( ctx, span);
+ }
+
+
+ if ((primitive==GL_BITMAP && (swrast->_RasterMask & modBits))
+ || (swrast->_RasterMask & MULTI_DRAW_BIT)) {
+ /* must make a copy of the colors since they may be modified */
+ MEMCPY( rgbaBackup, span->color.rgba, 4 * span->end * sizeof(GLchan) );
+ rgba = rgbaBackup;
+ }
+ else {
+ rgba = span->color.rgba;
}
+
/* Do the alpha test */
if (ctx->Color.AlphaEnabled) {
- if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4]) rgba, mask ) == 0) {
+ if (_mesa_alpha_test( ctx, span->end, (const GLchan (*)[4]) rgba, span->mask ) == 0) {
return;
}
- write_all = GL_FALSE;
+ span->write_all = GL_FALSE;
+ }
+
+ /* I have to think where to put this!! */
+ if (span->activeMask & SPAN_Z) {
+ SW_SPAN_SET_FLAG(span->filledDepth);
+
+ if (ctx->Visual.depthBits <= 16) {
+ GLuint i;
+ GLfixed zval = span->z;
+ for (i = 0; i < span->end; i++) {
+ span->depth[i] = FixedToInt(zval);
+ zval += span->zStep;
+ }
+ }
+ else {
+ /* Deep Z buffer, no fixed->int shift */
+ GLuint i;
+ GLfixed zval = span->z;
+ for (i = 0; i < span->end; i++) {
+ span->depth[i] = zval;
+ zval += span->zStep;
+ }
+ }
}
if (ctx->Stencil.Enabled) {
/* first stencil test */
- if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
- return;
- }
- write_all = GL_FALSE;
+ if (_mesa_stencil_and_ztest_span(ctx, span) == GL_FALSE)
+ return;
}
else if (ctx->Depth.Test) {
/* regular depth testing */
- GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
- if (m == 0) {
- return;
- }
- if (m < n) {
- write_all = GL_FALSE;
- }
+ if (_mesa_depth_test_span(ctx, span) == GL_FALSE)
+ return;
}
/* if we get here, something passed the depth test */
/* Per-pixel fog */
if (ctx->Fog.Enabled) {
- if (fog && !swrast->_PreferPixelFog)
- _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ /* Is this the right 'if' ?? */
+ if ((span->activeMask & SPAN_FOG) && !swrast->_PreferPixelFog)
+ _mesa_fog_rgba_pixels( ctx, span, rgba );
else
- _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ _mesa_depth_fog_rgba_pixels( ctx, span, rgba );
}
/* Antialias coverage application */
- if (coverage) {
+#if 0
+ if (span->coverage) {
GLuint i;
- for (i = 0; i < n; i++) {
- rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+ for (i = 0; i < span->end; i++) {
+ rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * span->coverage[i]);
}
}
+#endif
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
- multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
+ multi_write_rgba_span( ctx, span->end, span->x, span->y, (const GLchan (*)[4]) rgba, span->mask );
}
else {
/* normal: write to exactly one buffer */
const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
if (ctx->Color.ColorLogicOpEnabled) {
- _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+ _mesa_logicop_rgba_span( ctx, span->end, span->x, span->y, rgba, span->mask );
}
else if (ctx->Color.BlendEnabled) {
- _mesa_blend_span( ctx, n, x, y, rgba, mask );
+ _mesa_blend_span( ctx, span->end, span->x, span->y, rgba, span->mask );
}
/* Color component masking */
return;
}
else if (colorMask != 0xffffffff) {
- _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+ _mesa_mask_rgba_span( ctx, span->end, span->x, span->y, rgba );
}
/* write pixels */
- (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y,
+ (*swrast->Driver.WriteRGBASpan)( ctx, span->end, span->x, span->y,
(const GLchan (*)[4]) rgba,
- write_all ? ((const GLubyte *) NULL) : mask );
+ span->write_all ? ((const GLubyte *) NULL) : span->mask );
if (swrast->_RasterMask & ALPHABUF_BIT) {
- _mesa_write_alpha_span( ctx, n, x, y,
+ _mesa_write_alpha_span( ctx, span->end, span->x, span->y,
(const GLchan (*)[4]) rgba,
- write_all ? ((const GLubyte *) NULL) : mask );
+ span->write_all ? ((const GLubyte *) NULL) : span->mask );
}
}
}
-
/*
* Write a horizontal span of color pixels to the frame buffer.
* The color is initially constant for the whole span.
* Alpha-testing, stenciling, depth-testing, and blending are done as needed.
- * Input: n - number of pixels in the span
- * x, y - location of leftmost pixel in the span
- * z - array of [n] z-values
- * fog - array of fog factor values in [0,1]
- * r, g, b, a - the color of the pixels
+ * Input: r, g, b, a - the color of the pixels
* primitive - either GL_POINT, GL_LINE, GL_POLYGON or GL_BITMAP.
*/
void
-_mesa_write_monocolor_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- const GLdepth z[], const GLfloat fog[],
- const GLchan color[4], const GLfloat coverage[],
- GLenum primitive )
+_mesa_write_monocolor_span( GLcontext *ctx, struct sw_span *span,
+ const GLchan color[4], GLenum primitive )
{
const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
GLuint i;
- GLubyte mask[MAX_WIDTH];
- GLboolean write_all = GL_TRUE;
GLchan rgba[MAX_WIDTH][4];
SWcontext *swrast = SWRAST_CONTEXT(ctx);
- /* init mask to 1's (all pixels are to be written) */
- MEMSET(mask, 1, n);
+
+ SET_MASK_TO_ONE(span);
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if ((n = clip_span( ctx,n,x,y,mask)) == 0) {
+ if (clip_span(ctx,span) == GL_FALSE) {
return;
}
- if (mask[0] == 0)
- write_all = GL_FALSE;
}
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+ if (_mesa_scissor_span( ctx, span ) == GL_FALSE) {
return;
}
- if (mask[0] == 0)
- write_all = GL_FALSE;
}
/* Polygon Stippling */
if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
- stipple_polygon_span( ctx, n, x, y, mask );
- write_all = GL_FALSE;
+ stipple_polygon_span( ctx, span);
}
/* Do the alpha test */
if (ctx->Color.AlphaEnabled) {
- for (i = 0; i < n; i++) {
+ for (i = 0; i < span->end; i++) {
rgba[i][ACOMP] = color[ACOMP];
}
- if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4])rgba, mask ) == 0) {
+ if (_mesa_alpha_test( ctx, span->end, (const GLchan (*)[4])rgba, span->mask ) == 0) {
return;
}
- write_all = GL_FALSE;
+ span->write_all = GL_FALSE;
+ }
+
+ /* I have to think where to put this!! */
+ if (span->activeMask & SPAN_Z) {
+ SW_SPAN_SET_FLAG(span->filledDepth);
+
+ if (ctx->Visual.depthBits <= 16) {
+ GLuint i;
+ GLfixed zval = span->z;
+ for (i = 0; i < span->end; i++) {
+ span->depth[i] = FixedToInt(zval);
+ zval += span->zStep;
+ }
+ }
+ else {
+ /* Deep Z buffer, no fixed->int shift */
+ GLuint i;
+ GLfixed zval = span->z;
+ for (i = 0; i < span->end; i++) {
+ span->depth[i] = zval;
+ zval += span->zStep;
+ }
+ }
}
if (ctx->Stencil.Enabled) {
/* first stencil test */
- if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+ if (_mesa_stencil_and_ztest_span(ctx, span) == GL_FALSE)
return;
- }
- write_all = GL_FALSE;
}
else if (ctx->Depth.Test) {
/* regular depth testing */
- GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
- if (m == 0) {
+ if (_mesa_depth_test_span(ctx, span) == 0)
return;
- }
- if (m < n) {
- write_all = GL_FALSE;
- }
}
/* if we get here, something passed the depth test */
}
if (ctx->Color.ColorLogicOpEnabled || colorMask != 0xffffffff ||
+#if 0
(swrast->_RasterMask & (BLEND_BIT | FOG_BIT)) || coverage) {
+#else
+ (swrast->_RasterMask & (BLEND_BIT | FOG_BIT))) {
+#endif
/* assign same color to each pixel */
- for (i = 0; i < n; i++) {
- if (mask[i]) {
+ SW_SPAN_SET_FLAG(span->filledColor);
+ for (i = 0; i < span->end; i++) {
+ if (span->mask[i]) {
COPY_CHAN4(rgba[i], color);
}
}
/* Per-pixel fog */
if (ctx->Fog.Enabled) {
- if (fog && !swrast->_PreferPixelFog)
- _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ /* Is this the right 'if' ?? */
+ if ((span->activeMask & SPAN_FOG) && !swrast->_PreferPixelFog)
+ _mesa_fog_rgba_pixels( ctx, span, rgba );
else
- _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ _mesa_depth_fog_rgba_pixels( ctx, span, rgba );
}
/* Antialias coverage application */
- if (coverage) {
+#if 0
+ if (span->coverage) {
GLuint i;
- for (i = 0; i < n; i++) {
- rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+ for (i = 0; i < span->end; i++) {
+ rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * span->coverage[i]);
}
}
+#endif
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
- multi_write_rgba_span( ctx, n, x, y,
- (const GLchan (*)[4]) rgba, mask );
+ multi_write_rgba_span( ctx, span->end, span->x, span->y,
+ (const GLchan (*)[4]) rgba, span->mask );
}
else {
/* normal: write to exactly one buffer */
if (ctx->Color.ColorLogicOpEnabled) {
- _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+ _mesa_logicop_rgba_span( ctx, span->end, span->x, span->y, rgba, span->mask );
}
else if (ctx->Color.BlendEnabled) {
- _mesa_blend_span( ctx, n, x, y, rgba, mask );
+ _mesa_blend_span( ctx, span->end, span->x, span->y, rgba, span->mask );
}
/* Color component masking */
return;
}
else if (colorMask != 0xffffffff) {
- _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+ _mesa_mask_rgba_span( ctx, span->end, span->x, span->y, rgba );
}
/* write pixels */
- (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y,
+ (*swrast->Driver.WriteRGBASpan)( ctx, span->end, span->x, span->y,
(const GLchan (*)[4]) rgba,
- write_all ? ((const GLubyte *) NULL) : mask );
+ span->write_all ? ((const GLubyte *) NULL) : span->mask );
if (swrast->_RasterMask & ALPHABUF_BIT) {
- _mesa_write_alpha_span( ctx, n, x, y,
+ _mesa_write_alpha_span( ctx, span->end, span->x, span->y,
(const GLchan (*)[4]) rgba,
- write_all ? ((const GLubyte *) NULL) : mask );
+ span->write_all ? ((const GLubyte *) NULL) : span->mask );
}
}
}
ASSERT(!ctx->Color.ColorLogicOpEnabled);
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
- for (i = 0; i < n; i++) {
- if (mask[i]) {
+ SW_SPAN_SET_FLAG(span->filledColor);
+ for (i = 0; i < span->end; i++) {
+ if (span->mask[i]) {
COPY_CHAN4(rgba[i], color);
}
}
- multi_write_rgba_span( ctx, n, x, y,
- (const GLchan (*)[4]) rgba, mask );
+ multi_write_rgba_span( ctx, span->end, span->x, span->y,
+ (const GLchan (*)[4]) rgba, span->mask );
}
else {
- (*swrast->Driver.WriteMonoRGBASpan)( ctx, n, x, y, color, mask );
+ (*swrast->Driver.WriteMonoRGBASpan)( ctx, span->end, span->x, span->y, color, span->mask );
if (swrast->_RasterMask & ALPHABUF_BIT) {
- _mesa_write_mono_alpha_span( ctx, n, x, y, (GLchan) color[ACOMP],
- write_all ? ((const GLubyte *) NULL) : mask );
+ _mesa_write_mono_alpha_span( ctx, span->end, span->x, span->y, (GLchan) color[ACOMP],
+ span->write_all ? ((const GLubyte *) NULL) : span->mask );
}
}
}
* GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR.
*/
static void
-add_colors(GLuint n, GLchan rgba[][4], CONST GLchan specular[][4] )
+add_colors(CONST struct sw_span *span, GLchan rgba[][4])
{
GLuint i;
- for (i = 0; i < n; i++) {
+ ASSERT(span->filledSpecular == GL_TRUE);
+ ASSERT(span->filledColor == GL_TRUE);
+
+ for (i = 0; i < span->end; i++) {
#if CHAN_TYPE == GL_FLOAT
/* no clamping */
- rgba[i][RCOMP] += specular[i][RCOMP];
- rgba[i][GCOMP] += specular[i][GCOMP];
- rgba[i][BCOMP] += specular[i][BCOMP];
+ rgba[i][RCOMP] += span->specular[i][RCOMP];
+ rgba[i][GCOMP] += span->specular[i][GCOMP];
+ rgba[i][BCOMP] += span->specular[i][BCOMP];
#else
- GLint r = rgba[i][RCOMP] + specular[i][RCOMP];
- GLint g = rgba[i][GCOMP] + specular[i][GCOMP];
- GLint b = rgba[i][BCOMP] + specular[i][BCOMP];
+ GLint r = rgba[i][RCOMP] + span->specular[i][RCOMP];
+ GLint g = rgba[i][GCOMP] + span->specular[i][GCOMP];
+ GLint b = rgba[i][BCOMP] + span->specular[i][BCOMP];
rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
* Contributed by Klaus Niederkrueger.
*/
static void
-masked_texture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- const GLdepth z[], const GLfloat fog[],
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], GLfloat lambda[],
- GLchan rgbaIn[][4], CONST GLchan spec[][4],
- const GLfloat coverage[], GLubyte mask[],
- GLboolean write_all )
+masked_texture_span( GLcontext *ctx, struct sw_span *span)
{
const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
GLchan rgbaBackup[MAX_WIDTH][4];
- GLchan (*rgba)[4]; /* points to either rgbaIn or rgbaBackup */
+ GLchan (*rgba)[4]; /* points to either span->color.rgba or rgbaBackup */
SWcontext *swrast = SWRAST_CONTEXT(ctx);
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
/* must make a copy of the colors since they may be modified */
- MEMCPY(rgbaBackup, rgbaIn, 4 * n * sizeof(GLchan));
+ MEMCPY(rgbaBackup, span->color.rgba, 4 * span->end * sizeof(GLchan));
rgba = rgbaBackup;
}
else {
- rgba = rgbaIn;
+ rgba = span->color.rgba;
}
ASSERT(ctx->Texture._ReallyEnabled);
- _swrast_texture_fragments( ctx, 0, n, s, t, u, lambda,
- (CONST GLchan (*)[4]) rgba, rgba );
-
-
+ _swrast_texture_fragments( ctx, 0, span, rgba );
+
+
/* Texture with alpha test */
if (ctx->Color.AlphaEnabled) {
/* Do the alpha test */
- if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4]) rgba, mask ) == 0) {
+ if (_mesa_alpha_test( ctx, span->end, (const GLchan (*)[4]) rgba, span->mask ) == 0) {
return;
}
- write_all = GL_FALSE;
+ span->write_all = GL_FALSE;
/* Depth test usually in 'rasterize_span' but if alpha test
needed, we have to wait for that test before depth test can
be done. */
if (ctx->Stencil.Enabled) {
- /* first stencil test */
- if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
- return;
- }
- write_all = GL_FALSE;
+ /* first stencil test */
+ if (_mesa_stencil_and_ztest_span(ctx, span) == GL_FALSE)
+ return;
}
else if (ctx->Depth.Test) {
- /* regular depth testing */
- GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
- if (m == 0) {
- return;
- }
- if (m < n) {
- write_all = GL_FALSE;
- }
+ /* regular depth testing */
+ if (_mesa_depth_test_span(ctx, span) == 0)
+ return;
}
}
/* if we get here, something passed the depth test */
ctx->OcclusionResult = GL_TRUE;
-
-
+
+
/* Add base and specular colors */
- if (spec &&
+ if ((span->activeMask & SPAN_SPEC) && /* Is this right test ???*/
(ctx->Fog.ColorSumEnabled ||
(ctx->Light.Enabled &&
ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)))
- add_colors( n, rgba, spec ); /* rgba = rgba + spec */
-
+ add_colors(span, rgba); /* rgba = rgba + spec */
+
/* Per-pixel fog */
if (ctx->Fog.Enabled) {
- if (fog && !swrast->_PreferPixelFog)
- _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ /* Is this the right 'if' ?? */
+ if ((span->activeMask & SPAN_FOG) && !swrast->_PreferPixelFog)
+ _mesa_fog_rgba_pixels(ctx, span, rgba);
else
- _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ _mesa_depth_fog_rgba_pixels(ctx, span, rgba);
}
/* Antialias coverage application */
- if (coverage) {
+#if 0
+ if (span->coverage) {
GLuint i;
- for (i = 0; i < n; i++) {
- rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+ for (i = 0; i < span->end; i++) {
+ rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * span->coverage[i]);
}
}
+#endif
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
- multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
+ multi_write_rgba_span( ctx, span->end, span->x, span->y, (const GLchan (*)[4]) rgba, span->mask );
}
else {
/* normal: write to exactly one buffer */
if (ctx->Color.ColorLogicOpEnabled) {
- _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+ _mesa_logicop_rgba_span( ctx, span->end, span->x, span->y, rgba, span->mask );
}
else if (ctx->Color.BlendEnabled) {
- _mesa_blend_span( ctx, n, x, y, rgba, mask );
+ _mesa_blend_span( ctx, span->end, span->x, span->y, rgba, span->mask );
}
if (colorMask == 0x0) {
return;
}
else if (colorMask != 0xffffffff) {
- _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+ _mesa_mask_rgba_span( ctx, span->end, span->x, span->y, rgba );
}
- (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y, (const GLchan (*)[4])rgba,
- write_all ? NULL : mask );
+ (*swrast->Driver.WriteRGBASpan)( ctx, span->end, span->x, span->y, (const GLchan (*)[4])rgba,
+ span->write_all ? NULL : span->mask );
if (swrast->_RasterMask & ALPHABUF_BIT) {
- _mesa_write_alpha_span( ctx, n, x, y, (const GLchan (*)[4]) rgba,
- write_all ? NULL : mask );
+ _mesa_write_alpha_span( ctx, span->end, span->x, span->y, (const GLchan (*)[4]) rgba,
+ span->write_all ? NULL : span->mask );
}
}
}
* Contributed by Klaus Niederkrueger.
*/
static void
-masked_multitexture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- const GLdepth z[], const GLfloat fog[],
- CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
- CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
- CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH],
- GLfloat lambda[][MAX_WIDTH],
- GLchan rgbaIn[MAX_TEXTURE_UNITS][4],
- CONST GLchan spec[MAX_TEXTURE_UNITS][4],
- const GLfloat coverage[], GLubyte mask[],
- GLboolean write_all )
+masked_multitexture_span( GLcontext *ctx, struct sw_span *span)
{
GLchan rgbaBackup[MAX_WIDTH][4];
- GLchan (*rgba)[4]; /* points to either rgbaIn or rgbaBackup */
+ GLchan (*rgba)[4]; /* points to either span->color.rgba or rgbaBackup */
GLuint i;
const GLuint texUnits = ctx->Const.MaxTextureUnits;
SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
+
if ( (swrast->_RasterMask & MULTI_DRAW_BIT) || texUnits > 1) {
/* must make a copy of the colors since they may be modified */
- MEMCPY(rgbaBackup, rgbaIn, 4 * n * sizeof(GLchan));
+ MEMCPY(rgbaBackup, span->color.rgba, 4 * span->end * sizeof(GLchan));
rgba = rgbaBackup;
}
else {
- rgba = rgbaIn;
+ rgba = span->color.rgba;
}
-
-
+
+
ASSERT(ctx->Texture._ReallyEnabled);
for (i = 0; i < texUnits; i++)
- _swrast_texture_fragments( ctx, i, n, s[i], t[i], u[i], lambda[i],
- (CONST GLchan (*)[4]) rgbaIn, rgba );
+ _swrast_texture_fragments( ctx, i, span, rgba );
/* Texture with alpha test */
if (ctx->Color.AlphaEnabled) {
/* Do the alpha test */
- if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4])rgba, mask ) == 0) {
+ if (_mesa_alpha_test( ctx, span->end, (const GLchan (*)[4])rgba, span->mask ) == 0) {
return;
}
- write_all = GL_FALSE;
+ span->write_all = GL_FALSE;
/* Depth test usually in 'rasterize_span' but if alpha test
needed, we have to wait for that test before depth test can
be done. */
if (ctx->Stencil.Enabled) {
- /* first stencil test */
- if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
- return;
- }
- write_all = GL_FALSE;
+ /* first stencil test */
+ if (_mesa_stencil_and_ztest_span(ctx, span) == GL_FALSE)
+ return;
}
else if (ctx->Depth.Test) {
- /* regular depth testing */
- GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
- if (m == 0) {
- return;
- }
- if (m < n) {
- write_all = GL_FALSE;
- }
+ /* regular depth testing */
+ if (_mesa_depth_test_span(ctx, span) == GL_FALSE)
+ return;
}
}
/* if we get here, something passed the depth test */
ctx->OcclusionResult = GL_TRUE;
-
-
+
+
/* Add base and specular colors */
- if (spec &&
+ if ((span->activeMask & SPAN_SPEC) && /* Is this right test ???*/
(ctx->Fog.ColorSumEnabled ||
(ctx->Light.Enabled &&
ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)))
- add_colors( n, rgba, spec ); /* rgba = rgba + spec */
-
+ add_colors(span, rgba); /* rgba = rgba + spec */
+
/* Per-pixel fog */
if (ctx->Fog.Enabled) {
- if (fog && !swrast->_PreferPixelFog)
- _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ /* Is this the right 'if' ?? */
+ if ((span->activeMask & SPAN_FOG) && !swrast->_PreferPixelFog)
+ _mesa_fog_rgba_pixels( ctx, span, rgba );
else
- _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ _mesa_depth_fog_rgba_pixels( ctx, span, rgba );
}
-
+
/* Antialias coverage application */
- if (coverage) {
+#if 0
+ if (span->coverage) {
GLuint i;
- for (i = 0; i < n; i++) {
- rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+ for (i = 0; i < span->end; i++) {
+ rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * span->coverage[i]);
}
}
+#endif
if (swrast->_RasterMask & MULTI_DRAW_BIT) {
- multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
+ multi_write_rgba_span( ctx, span->end, span->x, span->y, (const GLchan (*)[4]) rgba, span->mask );
}
else {
/* normal: write to exactly one buffer */
const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
-
+
if (ctx->Color.ColorLogicOpEnabled) {
- _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+ _mesa_logicop_rgba_span( ctx, span->end, span->x, span->y, rgba, span->mask );
}
else if (ctx->Color.BlendEnabled) {
- _mesa_blend_span( ctx, n, x, y, rgba, mask );
+ _mesa_blend_span( ctx, span->end, span->x, span->y, rgba, span->mask );
}
if (colorMask == 0x0) {
return;
}
else if (colorMask != 0xffffffff) {
- _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+ _mesa_mask_rgba_span( ctx, span->end, span->x, span->y, rgba );
}
- (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y, (const GLchan (*)[4])rgba,
- write_all ? NULL : mask );
+ (*swrast->Driver.WriteRGBASpan)( ctx, span->end, span->x, span->y, (const GLchan (*)[4])rgba,
+ span->write_all ? NULL : span->mask );
if (swrast->_RasterMask & ALPHABUF_BIT) {
- _mesa_write_alpha_span( ctx, n, x, y, (const GLchan (*)[4])rgba,
- write_all ? NULL : mask );
+ _mesa_write_alpha_span( ctx, span->end, span->x, span->y, (const GLchan (*)[4])rgba,
+ span->write_all ? NULL : span->mask );
}
}
}
* Contributed by Klaus Niederkrueger.
*/
void
-_mesa_rasterize_span(GLcontext *ctx, struct triangle_span *span)
+_mesa_rasterize_span(GLcontext *ctx, struct sw_span *span)
{
- DEFARRAY(GLubyte, mask, MAX_WIDTH);
- DEFMARRAY(GLchan, rgba, MAX_WIDTH, 4);
- DEFMARRAY(GLchan, spec, MAX_WIDTH, 4);
- DEFARRAY(GLuint, index, MAX_WIDTH);
- DEFARRAY(GLuint, z, MAX_WIDTH);
- DEFARRAY(GLfloat, fog, MAX_WIDTH);
- DEFARRAY(GLfloat, sTex, MAX_WIDTH);
- DEFARRAY(GLfloat, tTex, MAX_WIDTH);
- DEFARRAY(GLfloat, rTex, MAX_WIDTH);
- DEFARRAY(GLfloat, lambda, MAX_WIDTH);
- DEFMARRAY(GLfloat, msTex, MAX_TEXTURE_UNITS, MAX_WIDTH);
- DEFMARRAY(GLfloat, mtTex, MAX_TEXTURE_UNITS, MAX_WIDTH);
- DEFMARRAY(GLfloat, mrTex, MAX_TEXTURE_UNITS, MAX_WIDTH);
- DEFMARRAY(GLfloat, mLambda, MAX_TEXTURE_UNITS, MAX_WIDTH);
-
- GLboolean write_all = GL_TRUE;
SWcontext *swrast = SWRAST_CONTEXT(ctx);
- CHECKARRAY(mask, return);
- CHECKARRAY(rgba, return);
- CHECKARRAY(spec, return);
- CHECKARRAY(index, return);
- CHECKARRAY(z, return);
- CHECKARRAY(fog, return);
- CHECKARRAY(sTex, return);
- CHECKARRAY(tTex, return);
- CHECKARRAY(rTex, return);
- CHECKARRAY(lambda, return);
- CHECKARRAY(msTex, return);
- CHECKARRAY(mtTex, return);
- CHECKARRAY(mrTex, return);
- CHECKARRAY(mLambda, return);
+ SET_MASK_TO_ONE(span);
- /* init mask to 1's (all pixels are to be written) */
- MEMSET(mask, 1, span->count);
if (swrast->_RasterMask & WINCLIP_BIT) {
- if ((span->count = clip_span(ctx, span->count, span->x, span->y, mask))
- == 0) {
+ if (clip_span(ctx, span) == GL_FALSE) {
return;
}
- if (mask[0] == 0)
- write_all = GL_FALSE;
}
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if ((span->count = _mesa_scissor_span(ctx, span->count, span->x, span->y, mask )) == 0) {
+ if (_mesa_scissor_span( ctx, span ) == GL_FALSE) {
return;
}
- if (mask[0] == 0)
- write_all = GL_FALSE;
}
/* Polygon Stippling */
if (ctx->Polygon.StippleFlag) {
- stipple_polygon_span( ctx, span->count, span->x, span->y, mask );
- write_all = GL_FALSE;
+ stipple_polygon_span( ctx, span );
}
-
-
+ /* I have to think where to put this!! */
if (span->activeMask & SPAN_Z) {
+ SW_SPAN_SET_FLAG(span->filledDepth);
+
if (ctx->Visual.depthBits <= 16) {
GLuint i;
GLfixed zval = span->z;
- for (i = 0; i < span->count; i++) {
- z[i] = FixedToInt(zval);
+ for (i = 0; i < span->end; i++) {
+ span->depth[i] = FixedToInt(zval);
zval += span->zStep;
}
}
/* Deep Z buffer, no fixed->int shift */
GLuint i;
GLfixed zval = span->z;
- for (i = 0; i < span->count; i++) {
- z[i] = zval;
+ for (i = 0; i < span->end; i++) {
+ span->depth[i] = zval;
zval += span->zStep;
}
}
no alpha test needed, we can do here the depth test and
potentially avoid some of the texturing (otherwise alpha test,
depth test etc. happens in masked_texture_span(). */
- if (!ctx->Color.AlphaEnabled) {
+ if (span->activeMask & SPAN_Z && !ctx->Color.AlphaEnabled) {
if (ctx->Stencil.Enabled) {
/* first stencil test */
- if (_mesa_stencil_and_ztest_span(ctx, span->count, span->x,
- span->y, z, mask) == GL_FALSE) {
+ if (_mesa_stencil_and_ztest_span(ctx, span) == GL_FALSE)
return;
- }
- write_all = GL_FALSE;
}
else if (ctx->Depth.Test) {
/* regular depth testing */
- GLuint m = _mesa_depth_test_span( ctx, span->count, span->x,
- span->y, z, mask );
- if (m == 0) {
- return;
- }
- if (m < span->count) {
- write_all = GL_FALSE;
+ if (_mesa_depth_test_span( ctx, span) == 0) {
+ return;
}
}
}
if (span->activeMask & SPAN_RGBA) {
+ ASSERT(span->filledColor == GL_FALSE);
+ SW_SPAN_SET_FLAG(span->filledColor);
if (span->activeMask & SPAN_FLAT) {
GLuint i;
GLchan color[4];
color[GCOMP] = FixedToChan(span->green);
color[BCOMP] = FixedToChan(span->blue);
color[ACOMP] = FixedToChan(span->alpha);
- for (i = 0; i < span->count; i++) {
- COPY_CHAN4(rgba[i], color);
+ for (i = 0; i < span->end; i++) {
+ COPY_CHAN4(span->color.rgba[i], color);
}
}
else {
GLfixed a = span->alpha;
#endif
GLuint i;
- for (i = 0; i < span->count; i++) {
- rgba[i][RCOMP] = FixedToChan(r);
- rgba[i][GCOMP] = FixedToChan(g);
- rgba[i][BCOMP] = FixedToChan(b);
- rgba[i][ACOMP] = FixedToChan(a);
+ for (i = 0; i < span->end; i++) {
+ span->color.rgba[i][RCOMP] = FixedToChan(r);
+ span->color.rgba[i][GCOMP] = FixedToChan(g);
+ span->color.rgba[i][BCOMP] = FixedToChan(b);
+ span->color.rgba[i][ACOMP] = FixedToChan(a);
r += span->redStep;
g += span->greenStep;
b += span->blueStep;
}
if (span->activeMask & SPAN_SPEC) {
+ SW_SPAN_SET_FLAG(span->filledSpecular);
if (span->activeMask & SPAN_FLAT) {
const GLchan r = FixedToChan(span->specRed);
const GLchan g = FixedToChan(span->specGreen);
const GLchan b = FixedToChan(span->specBlue);
GLuint i;
- for (i = 0; i < span->count; i++) {
- spec[i][RCOMP] = r;
- spec[i][GCOMP] = g;
- spec[i][BCOMP] = b;
+ for (i = 0; i < span->end; i++) {
+ span->specular[i][RCOMP] = r;
+ span->specular[i][GCOMP] = g;
+ span->specular[i][BCOMP] = b;
}
}
else {
GLfixed b = span->specBlue;
#endif
GLuint i;
- for (i = 0; i < span->count; i++) {
- spec[i][RCOMP] = FixedToChan(r);
- spec[i][GCOMP] = FixedToChan(g);
- spec[i][BCOMP] = FixedToChan(b);
+ for (i = 0; i < span->end; i++) {
+ span->specular[i][RCOMP] = FixedToChan(r);
+ span->specular[i][GCOMP] = FixedToChan(g);
+ span->specular[i][BCOMP] = FixedToChan(b);
r += span->specRedStep;
g += span->specGreenStep;
b += span->specBlueStep;
}
if (span->activeMask & SPAN_INDEX) {
+ SW_SPAN_SET_FLAG(span->filledColor);
if (span->activeMask & SPAN_FLAT) {
GLuint i;
const GLint indx = FixedToInt(span->index);
- for (i = 0; i < span->count; i++) {
- index[i] = indx;
+ for (i = 0; i < span->end; i++) {
+ span->color.index[i] = indx;
}
}
else {
/* smooth interpolation */
GLuint i;
GLfixed ind = span->index;
- for (i = 0; i < span->count; i++) {
- index[i] = FixedToInt(ind);
+ for (i = 0; i < span->end; i++) {
+ span->color.index[i] = FixedToInt(ind);
ind += span->indexStep;
}
}
}
- if (span->activeMask & SPAN_FOG) {
- GLuint i;
- GLfloat f = span->fog;
- for (i = 0; i < span->count; i++) {
- fog[i] = f;
- f += span->fogStep;
- }
- }
if (span->activeMask & SPAN_TEXTURE) {
if (ctx->Texture._ReallyEnabled & ~TEXTURE0_ANY) {
/* multitexture */
GLuint u;
/* multitexture, lambda */
for (u = 0; u < MAX_TEXTURE_UNITS; u++) {
- if (ctx->Texture.Unit[u]._ReallyEnabled) {
+ if (ctx->Texture.Unit[u]._ReallyEnabled) {
GLfloat s = span->tex[u][0];
GLfloat t = span->tex[u][1];
GLfloat r = span->tex[u][2];
GLfloat q = span->tex[u][3];
GLuint i;
- for (i = 0; i < span->count; i++) {
- const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
- msTex[u][i] = s * invQ;
- mtTex[u][i] = t * invQ;
- mrTex[u][i] = r * invQ;
- mLambda[u][i] = (GLfloat)
- (log(span->rho[u] * invQ * invQ) * 1.442695F * 0.5F);
- s += span->texStep[u][0];
- t += span->texStep[u][1];
- r += span->texStep[u][2];
- q += span->texStep[u][3];
+ SW_SPAN_SET_FLAG(span->filledLambda[u]);
+ SW_SPAN_SET_FLAG(span->filledTex[u]);
+ for (i = 0; i < span->end; i++) {
+ const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
+ span->texcoords[u][i][0] = s * invQ;
+ span->texcoords[u][i][1] = t * invQ;
+ span->texcoords[u][i][2] = r * invQ;
+ span->lambda[u][i] = (GLfloat)
+ (log(span->rho[u] * invQ * invQ) * 1.442695F * 0.5F);
+ s += span->texStep[u][0];
+ t += span->texStep[u][1];
+ r += span->texStep[u][2];
+ q += span->texStep[u][3];
}
- }
- }
+ }
+ }
}
else {
/* without lambda */
GLuint u;
/* multitexture, no lambda */
for (u = 0; u < MAX_TEXTURE_UNITS; u++) {
- if (ctx->Texture.Unit[u]._ReallyEnabled) {
+ if (ctx->Texture.Unit[u]._ReallyEnabled) {
GLfloat s = span->tex[u][0];
GLfloat t = span->tex[u][1];
GLfloat r = span->tex[u][2];
GLfloat q = span->tex[u][3];
GLuint i;
- for (i = 0; i < span->count; i++) {
- const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
- msTex[u][i] = s * invQ;
- mtTex[u][i] = t * invQ;
- mrTex[u][i] = r * invQ;
- s += span->texStep[u][0];
- t += span->texStep[u][1];
- r += span->texStep[u][2];
- q += span->texStep[u][3];
+ SW_SPAN_SET_FLAG(span->filledTex[u]);
+ for (i = 0; i < span->end; i++) {
+ const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
+ span->texcoords[u][i][0] = s * invQ;
+ span->texcoords[u][i][1] = t * invQ;
+ span->texcoords[u][i][2] = r * invQ;
+ s += span->texStep[u][0];
+ t += span->texStep[u][1];
+ r += span->texStep[u][2];
+ q += span->texStep[u][3];
}
- }
- }
+ }
+ }
}
}
else {
/* just texture unit 0 */
+#ifdef DEBUG
+ {GLint i;
+ for (i=0; i<MAX_TEXTURE_UNITS; i++) {
+ ASSERT(span->filledTex[i] == GL_FALSE &&
+ span->filledLambda[i] == GL_FALSE);
+ }}
+#endif
if (span->activeMask & SPAN_LAMBDA) {
/* with lambda */
GLfloat s = span->tex[0][0];
GLfloat r = span->tex[0][2];
GLfloat q = span->tex[0][3];
GLuint i;
+ SW_SPAN_SET_FLAG(span->filledLambda[0]);
+ SW_SPAN_SET_FLAG(span->filledTex[0]);
/* single texture, lambda */
- for (i = 0; i < span->count; i++) {
- const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
- sTex[i] = s * invQ;
- tTex[i] = t * invQ;
- rTex[i] = r * invQ;
- lambda[i] = (GLfloat)
- (log(span->rho[0] * invQ * invQ) * 1.442695F * 0.5F);
- s += span->texStep[0][0];
- t += span->texStep[0][1];
- r += span->texStep[0][2];
- q += span->texStep[0][3];
- }
+ for (i = 0; i < span->end; i++) {
+ const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
+ span->texcoords[0][i][0] = s * invQ;
+ span->texcoords[0][i][1] = t * invQ;
+ span->texcoords[0][i][2] = r * invQ;
+ span->lambda[0][i] = (GLfloat)
+ (log(span->rho[0] * invQ * invQ) * 1.442695F * 0.5F);
+ s += span->texStep[0][0];
+ t += span->texStep[0][1];
+ r += span->texStep[0][2];
+ q += span->texStep[0][3];
+ }
}
else {
/* without lambda */
GLfloat r = span->tex[0][2];
GLfloat q = span->tex[0][3];
GLuint i;
+ SW_SPAN_SET_FLAG(span->filledTex[0]);
/* single texture, no lambda */
- for (i = 0; i < span->count; i++) {
- const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
- sTex[i] = s * invQ;
- tTex[i] = t * invQ;
- rTex[i] = r * invQ;
- s += span->texStep[0][0];
- t += span->texStep[0][1];
- r += span->texStep[0][2];
- q += span->texStep[0][3];
+ for (i = 0; i < span->end; i++) {
+ const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
+ span->texcoords[0][i][0] = s * invQ;
+ span->texcoords[0][i][1] = t * invQ;
+ span->texcoords[0][i][2] = r * invQ;
+ s += span->texStep[0][0];
+ t += span->texStep[0][1];
+ r += span->texStep[0][2];
+ q += span->texStep[0][3];
}
}
}
}
/* XXX keep this? */
if (span->activeMask & SPAN_INT_TEXTURE) {
- GLint intTexcoord[MAX_WIDTH][2];
GLfixed s = span->intTex[0];
GLfixed t = span->intTex[1];
GLuint i;
- for (i = 0; i < span->count; i++) {
- intTexcoord[i][0] = FixedToInt(s);
- intTexcoord[i][1] = FixedToInt(t);
+ for (i = 0; i < span->end; i++) {
+ span->itexcoords[i][0] = FixedToInt(s);
+ span->itexcoords[i][1] = FixedToInt(t);
s += span->intTexStep[0];
t += span->intTexStep[1];
}
}
-
+
/* examine activeMask and call a s_span.c function */
if (span->activeMask & SPAN_TEXTURE) {
- const GLfloat *fogPtr;
- if (span->activeMask & SPAN_FOG)
- fogPtr = fog;
- else
- fogPtr = NULL;
if (ctx->Texture._ReallyEnabled & ~TEXTURE0_ANY) {
- if (span->activeMask & SPAN_SPEC) {
- masked_multitexture_span(ctx, span->count, span->x, span->y,
- z, fogPtr,
- (const GLfloat (*)[MAX_WIDTH]) msTex,
- (const GLfloat (*)[MAX_WIDTH]) mtTex,
- (const GLfloat (*)[MAX_WIDTH]) mrTex,
- (GLfloat (*)[MAX_WIDTH]) mLambda,
- rgba, (CONST GLchan (*)[4]) spec,
- NULL, mask, write_all );
- }
- else {
- masked_multitexture_span(ctx, span->count, span->x, span->y,
- z, fogPtr,
- (const GLfloat (*)[MAX_WIDTH]) msTex,
- (const GLfloat (*)[MAX_WIDTH]) mtTex,
- (const GLfloat (*)[MAX_WIDTH]) mrTex,
- (GLfloat (*)[MAX_WIDTH]) mLambda,
- rgba, NULL, NULL, mask, write_all );
- }
+ /* multi texture */
+ masked_multitexture_span(ctx, span);
}
else {
/* single texture */
- if (span->activeMask & SPAN_SPEC) {
- masked_texture_span(ctx, span->count, span->x, span->y,
- z, fogPtr, sTex, tTex, rTex,
- lambda, rgba,
- (CONST GLchan (*)[4]) spec,
- NULL, mask, write_all);
- }
- else {
- masked_texture_span(ctx, span->count, span->x, span->y,
- z, fogPtr, sTex, tTex, rTex,
- lambda, rgba, NULL, NULL,
- mask, write_all);
- }
+ masked_texture_span(ctx, span);
}
}
else {
_mesa_problem(ctx, "rasterize_span() should only be used for texturing");
}
- UNDEFARRAY(mask);
- UNDEFARRAY(rgba);
- UNDEFARRAY(spec);
- UNDEFARRAY(index);
- UNDEFARRAY(z);
- UNDEFARRAY(fog);
- UNDEFARRAY(sTex);
- UNDEFARRAY(tTex);
- UNDEFARRAY(rTex);
- UNDEFARRAY(lambda);
- UNDEFARRAY(msTex);
- UNDEFARRAY(mtTex);
- UNDEFARRAY(mrTex);
- UNDEFARRAY(mLambda);
+}
+
+/*
+ * Add specular color to base color. This is used only when
+ * GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR.
+ */
+static void
+_old_add_colors(GLuint n, GLchan rgba[][4], GLchan specular[][4] )
+{
+ GLuint i;
+ for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+ /* no clamping */
+ rgba[i][RCOMP] += specular[i][RCOMP];
+ rgba[i][GCOMP] += specular[i][GCOMP];
+ rgba[i][BCOMP] += specular[i][BCOMP];
+#else
+ GLint r = rgba[i][RCOMP] + specular[i][RCOMP];
+ GLint g = rgba[i][GCOMP] + specular[i][GCOMP];
+ GLint b = rgba[i][BCOMP] + specular[i][BCOMP];
+ rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
+ rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
+ rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
+#endif
+ }
}
* primitive - either GL_POINT, GL_LINE, GL_POLYGON or GL_BITMAP.
*/
void
-_mesa_write_texture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- const GLdepth z[], const GLfloat fog[],
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], GLfloat lambda[],
- GLchan rgbaIn[][4], CONST GLchan spec[][4],
- const GLfloat coverage[], GLenum primitive )
+_old_write_texture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], const GLfloat fog[],
+ GLfloat texcoord[][3],
+ GLfloat lambda[],
+ GLchan rgbaIn[][4], GLchan spec[][4],
+ const GLfloat coverage[], GLenum primitive )
{
const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
GLubyte mask[MAX_WIDTH];
MEMSET(mask, 1, n);
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if ((n=clip_span(ctx, n, x, y, mask)) == 0) {
+ if ((n=old_clip_span(ctx, n, x, y, mask)) == 0) {
return;
}
if (mask[0] == 0)
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+ if ((n = _old_scissor_span( ctx, n, x, y, mask )) == 0) {
return;
}
if (mask[0] == 0)
/* Polygon Stippling */
if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
- stipple_polygon_span( ctx, n, x, y, mask );
+ old_stipple_polygon_span( ctx, n, x, y, mask );
write_all = GL_FALSE;
}
/* Texturing without alpha is done after depth-testing which
gives a potential speed-up. */
ASSERT(ctx->Texture._ReallyEnabled);
- _swrast_texture_fragments( ctx, 0, n, s, t, u, lambda,
+ _old_swrast_texture_fragments( ctx, 0, n, texcoord, lambda,
(CONST GLchan (*)[4]) rgba, rgba );
/* Do the alpha test */
if (ctx->Stencil.Enabled) {
/* first stencil test */
- if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+ if (_old_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
return;
}
write_all = GL_FALSE;
}
else if (ctx->Depth.Test) {
/* regular depth testing */
- GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
+ GLuint m = _old_depth_test_span( ctx, n, x, y, z, mask );
if (m == 0) {
return;
}
/* Texture without alpha test */
if (! ctx->Color.AlphaEnabled) {
ASSERT(ctx->Texture._ReallyEnabled);
- _swrast_texture_fragments( ctx, 0, n, s, t, u, lambda,
+ _old_swrast_texture_fragments( ctx, 0, n, texcoord, lambda,
(CONST GLchan (*)[4]) rgba, rgba );
}
(ctx->Fog.ColorSumEnabled ||
(ctx->Light.Enabled &&
ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)))
- add_colors( n, rgba, spec ); /* rgba = rgba + spec */
+ _old_add_colors( n, rgba, spec ); /* rgba = rgba + spec */
/* Per-pixel fog */
if (ctx->Fog.Enabled) {
if (fog && !swrast->_PreferPixelFog)
- _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ _old_fog_rgba_pixels( ctx, n, fog, rgba );
else
- _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ _old_depth_fog_rgba_pixels( ctx, n, z, rgba );
}
/* Antialias coverage application */
* As above but perform multiple stages of texture application.
*/
void
-_mesa_write_multitexture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- const GLdepth z[], const GLfloat fog[],
- CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
- CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
- CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH],
- GLfloat lambda[][MAX_WIDTH],
- GLchan rgbaIn[MAX_TEXTURE_UNITS][4],
- CONST GLchan spec[MAX_TEXTURE_UNITS][4],
- const GLfloat coverage[],
- GLenum primitive )
+_old_write_multitexture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], const GLfloat fog[],
+ GLfloat texcoord[MAX_TEXTURE_UNITS][MAX_WIDTH][3],
+ GLfloat lambda[][MAX_WIDTH],
+ GLchan rgbaIn[MAX_TEXTURE_UNITS][4],
+ GLchan spec[MAX_TEXTURE_UNITS][4],
+ const GLfloat coverage[],
+ GLenum primitive )
{
GLubyte mask[MAX_WIDTH];
GLboolean write_all = GL_TRUE;
MEMSET(mask, 1, n);
if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
- if ((n=clip_span(ctx, n, x, y, mask)) == 0) {
+ if ((n=old_clip_span(ctx, n, x, y, mask)) == 0) {
return;
}
if (mask[0] == 0)
/* Do the scissor test */
if (ctx->Scissor.Enabled) {
- if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+ if ((n = _old_scissor_span( ctx, n, x, y, mask )) == 0) {
return;
}
if (mask[0] == 0)
/* Polygon Stippling */
if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
- stipple_polygon_span( ctx, n, x, y, mask );
+ old_stipple_polygon_span( ctx, n, x, y, mask );
write_all = GL_FALSE;
}
*/
ASSERT(ctx->Texture._ReallyEnabled);
for (i = 0; i < texUnits; i++)
- _swrast_texture_fragments( ctx, i, n, s[i], t[i], u[i], lambda[i],
+ _old_swrast_texture_fragments( ctx, i, n, texcoord[i], lambda[i],
(CONST GLchan (*)[4]) rgbaIn, rgba );
/* Do the alpha test */
if (ctx->Stencil.Enabled) {
/* first stencil test */
- if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+ if (_old_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
return;
}
write_all = GL_FALSE;
}
else if (ctx->Depth.Test) {
/* regular depth testing */
- GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
+ GLuint m = _old_depth_test_span( ctx, n, x, y, z, mask );
if (m == 0) {
return;
}
if (! ctx->Color.AlphaEnabled) {
ASSERT(ctx->Texture._ReallyEnabled);
for (i = 0; i < texUnits; i++)
- _swrast_texture_fragments( ctx, i, n, s[i], t[i], u[i], lambda[i],
+ _old_swrast_texture_fragments( ctx, i, n, texcoord[i], lambda[i],
(CONST GLchan (*)[4]) rgbaIn, rgba );
}
(ctx->Fog.ColorSumEnabled ||
(ctx->Light.Enabled &&
ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)))
- add_colors( n, rgba, spec ); /* rgba = rgba + spec */
+ _old_add_colors( n, rgba, spec ); /* rgba = rgba + spec */
/* Per-pixel fog */
if (ctx->Fog.Enabled) {
if (fog && !swrast->_PreferPixelFog)
- _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ _old_fog_rgba_pixels( ctx, n, fog, rgba );
else
- _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+ _old_depth_fog_rgba_pixels( ctx, n, z, rgba );
}
/* Antialias coverage application */
-/* $Id: s_span.h,v 1.7 2001/11/19 01:18:28 brianp Exp $ */
+/* $Id: s_span.h,v 1.8 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
#include "mtypes.h"
#include "swrast.h"
-#include "s_trispan.h"
extern void
-_mesa_write_index_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+_old_write_index_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
const GLdepth z[], const GLfloat fog[],
GLuint index[], const GLint coverage[],
GLenum primitive );
-
extern void
-_mesa_write_monoindex_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- const GLdepth z[], const GLfloat fog[],
- GLuint index, const GLint coverage[],
- GLenum primitive );
-
-
-extern void
-_mesa_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+_old_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
const GLdepth z[], const GLfloat fog[],
GLchan rgba[][4], const GLfloat coverage[],
GLenum primitive );
+void
+_mesa_write_index_span( GLcontext *ctx, struct sw_span *span,
+ GLenum primitive);
+
+extern void
+_mesa_write_monoindex_span( GLcontext *ctx, struct sw_span *span,
+ GLuint index, GLenum primitive );
+
+extern void
+_mesa_write_rgba_span( GLcontext *ctx, struct sw_span *span,
+ GLenum primitive );
extern void
-_mesa_write_monocolor_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- const GLdepth z[], const GLfloat fog[],
- const GLchan color[4], const GLfloat coverage[],
- GLenum primitive );
+_mesa_write_monocolor_span( GLcontext *ctx, struct sw_span *span,
+ const GLchan color[4], GLenum primitive );
extern void
-_mesa_rasterize_span(GLcontext *ctx, struct triangle_span *span);
+_mesa_rasterize_span(GLcontext *ctx, struct sw_span *span);
extern void
-_mesa_write_texture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
- const GLdepth z[], const GLfloat fog[],
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], GLfloat lambda[],
- GLchan rgba[][4], CONST GLchan spec[][4],
- const GLfloat coverage[], GLenum primitive );
+_old_write_texture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLdepth z[], const GLfloat fog[],
+ GLfloat texcoord[][3], GLfloat lambda[],
+ GLchan rgba[][4], GLchan spec[][4],
+ const GLfloat coverage[], GLenum primitive );
extern void
-_mesa_write_multitexture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+_old_write_multitexture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
const GLdepth z[], const GLfloat fog[],
- CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
- CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
- CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH],
+ GLfloat texcoord[MAX_TEXTURE_UNITS][MAX_WIDTH][3],
GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH],
- GLchan rgba[][4], CONST GLchan spec[][4],
+ GLchan rgba[][4], GLchan spec[][4],
const GLfloat coverage[], GLenum primitive );
-/* $Id: s_stencil.c,v 1.12 2001/05/17 20:18:45 brianp Exp $ */
+/* $Id: s_stencil.c,v 1.13 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
MEMCPY(oldmask, mask, n * sizeof(GLubyte));
/* apply the depth test */
- _mesa_depth_test_span(ctx, n, x, y, z, mask);
+ _old_depth_test_span(ctx, n, x, y, z, mask);
/* Set the stencil pass/fail flags according to result of depth testing.
* if oldmask[i] == 0 then
*
*/
GLboolean
-_mesa_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+_old_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
const GLdepth z[], GLubyte mask[] )
{
SWcontext *swrast = SWRAST_CONTEXT(ctx);
return result;
}
+/*
+ * Apply stencil and depth testing to the span of pixels.
+ * Both software and hardware stencil buffers are acceptable.
+ * Input: n - number of pixels in the span
+ * x, y - location of leftmost pixel in span
+ * z - array [n] of z values
+ * mask - array [n] of flags (1=test this pixel, 0=skip the pixel)
+ * Output: mask - array [n] of flags (1=stencil and depth test passed)
+ * Return: GL_TRUE - all fragments failed the testing
+ * GL_FALSE - one or more fragments passed the testing
+ *
+ */
+GLboolean
+_mesa_stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+ GLstencil stencilRow[MAX_WIDTH];
+ GLstencil *stencil;
+ GLboolean result;
+
+ ASSERT(ctx->Stencil.Enabled);
+ ASSERT(span->end <= MAX_WIDTH);
+ ASSERT(span->filledMask == GL_TRUE);
+ ASSERT(span->filledDepth == GL_TRUE);
+ SW_SPAN_SET_FLAG(span->testedDepth);
+
+
+ /* Get initial stencil values */
+ if (swrast->Driver.WriteStencilSpan) {
+ ASSERT(swrast->Driver.ReadStencilSpan);
+ /* Get stencil values from the hardware stencil buffer */
+ (*swrast->Driver.ReadStencilSpan)(ctx, span->end, span->x, span->y, stencilRow);
+ stencil = stencilRow;
+ }
+ else {
+ /* software stencil buffer */
+ stencil = STENCIL_ADDRESS(span->x, span->y);
+ }
+
+ /* do all the stencil/depth testing/updating */
+ result = stencil_and_ztest_span( ctx, span->end, span->x, span->y,
+ span->depth, stencil, span->mask );
+
+ if (swrast->Driver.WriteStencilSpan) {
+ /* Write updated stencil values into hardware stencil buffer */
+ (swrast->Driver.WriteStencilSpan)(ctx, span->end, span->x,
+ span->y, stencil, span->mask );
+ }
+
+ span->write_all = GL_FALSE;
+
+ return result;
+}
+
-/* $Id: s_stencil.h,v 1.3 2001/03/12 00:48:42 gareth Exp $ */
+/* $Id: s_stencil.h,v 1.4 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
extern GLboolean
-_mesa_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+_old_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
const GLdepth z[], GLubyte mask[] );
+extern GLboolean
+_mesa_stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span);
+
extern GLboolean
_mesa_stencil_and_ztest_pixels( GLcontext *ctx, GLuint n,
-/* $Id: s_texture.c,v 1.43 2001/12/04 23:44:56 brianp Exp $ */
+/* $Id: s_texture.c,v 1.44 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
static void
sample_nearest_1d( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
+ GLfloat texcoords[][3], const GLfloat lambda[],
GLchan rgba[][4] )
{
GLuint i;
struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
- (void) t;
- (void) u;
(void) lambda;
for (i=0;i<n;i++) {
- sample_1d_nearest(ctx, tObj, image, s[i], rgba[i]);
+ sample_1d_nearest(ctx, tObj, image, texcoords[i][0], rgba[i]);
}
}
static void
sample_linear_1d( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
+ GLfloat texcoords[][3], const GLfloat lambda[],
GLchan rgba[][4] )
{
GLuint i;
struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
- (void) t;
- (void) u;
(void) lambda;
for (i=0;i<n;i++) {
- sample_1d_linear(ctx, tObj, image, s[i], rgba[i]);
+ sample_1d_linear(ctx, tObj, image, texcoords[i][0], rgba[i]);
}
}
static void
sample_lambda_1d( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
- GLchan rgba[][4] )
+ GLfloat texcoords[][3],
+ const GLfloat lambda[], GLchan rgba[][4] )
{
GLfloat MinMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit];
GLuint i;
- (void) t;
- (void) u;
-
for (i=0;i<n;i++) {
if (lambda[i] > MinMagThresh) {
/* minification */
switch (tObj->MinFilter) {
case GL_NEAREST:
sample_1d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
- s[i], rgba[i]);
+ texcoords[i][0], rgba[i]);
break;
case GL_LINEAR:
sample_1d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
- s[i], rgba[i]);
+ texcoords[i][0], rgba[i]);
break;
case GL_NEAREST_MIPMAP_NEAREST:
- sample_1d_nearest_mipmap_nearest(ctx, tObj, lambda[i], s[i],
+ sample_1d_nearest_mipmap_nearest(ctx, tObj, lambda[i], texcoords[i][0],
rgba[i]);
break;
case GL_LINEAR_MIPMAP_NEAREST:
- sample_1d_linear_mipmap_nearest(ctx, tObj, s[i], lambda[i],
+ sample_1d_linear_mipmap_nearest(ctx, tObj, texcoords[i][0], lambda[i],
rgba[i]);
break;
case GL_NEAREST_MIPMAP_LINEAR:
- sample_1d_nearest_mipmap_linear(ctx, tObj, s[i], lambda[i],
+ sample_1d_nearest_mipmap_linear(ctx, tObj, texcoords[i][0], lambda[i],
rgba[i]);
break;
case GL_LINEAR_MIPMAP_LINEAR:
- sample_1d_linear_mipmap_linear(ctx, tObj, s[i], lambda[i],
+ sample_1d_linear_mipmap_linear(ctx, tObj, texcoords[i][0], lambda[i],
rgba[i]);
break;
default:
switch (tObj->MagFilter) {
case GL_NEAREST:
sample_1d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
- s[i], rgba[i]);
+ texcoords[i][0], rgba[i]);
break;
case GL_LINEAR:
sample_1d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
- s[i], rgba[i]);
+ texcoords[i][0], rgba[i]);
break;
default:
_mesa_problem(NULL, "Bad mag filter in sample_1d_texture");
static void
sample_nearest_2d( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
- GLchan rgba[][4] )
+ GLfloat texcoords[][3],
+ const GLfloat lambda[], GLchan rgba[][4] )
{
GLuint i;
struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
- (void) u;
(void) lambda;
for (i=0;i<n;i++) {
- sample_2d_nearest(ctx, tObj, image, s[i], t[i], rgba[i]);
+ sample_2d_nearest(ctx, tObj, image, texcoords[i][0],
+ texcoords[i][1], rgba[i]);
}
}
static void
sample_linear_2d( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
- GLchan rgba[][4] )
+ GLfloat texcoords[][3],
+ const GLfloat lambda[], GLchan rgba[][4] )
{
GLuint i;
struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
- (void) u;
(void) lambda;
for (i=0;i<n;i++) {
- sample_2d_linear(ctx, tObj, image, s[i], t[i], rgba[i]);
+ sample_2d_linear(ctx, tObj, image, texcoords[i][0],
+ texcoords[i][1], rgba[i]);
}
}
static void
opt_sample_rgb_2d( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj,
- GLuint n, const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
+ GLuint n, GLfloat texcoords[][3],
+ const GLfloat lambda[],
GLchan rgba[][4] )
{
const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
const GLint rowMask = img->Height - 1;
const GLint shift = img->WidthLog2;
GLuint k;
- (void) u;
(void) lambda;
ASSERT(tObj->WrapS==GL_REPEAT);
ASSERT(tObj->WrapT==GL_REPEAT);
ASSERT(img->Format==GL_RGB);
for (k=0; k<n; k++) {
- GLint i = IFLOOR(s[k] * width) & colMask;
- GLint j = IFLOOR(t[k] * height) & rowMask;
+ GLint i = IFLOOR(texcoords[k][0] * width) & colMask;
+ GLint j = IFLOOR(texcoords[k][1] * height) & rowMask;
GLint pos = (j << shift) | i;
GLchan *texel = ((GLchan *) img->Data) + 3*pos;
rgba[k][RCOMP] = texel[0];
static void
opt_sample_rgba_2d( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj,
- GLuint n, const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
+ GLuint n, GLfloat texcoords[][3],
+ const GLfloat lambda[],
GLchan rgba[][4] )
{
const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
const GLint rowMask = img->Height - 1;
const GLint shift = img->WidthLog2;
GLuint i;
- (void) u;
(void) lambda;
ASSERT(tObj->WrapS==GL_REPEAT);
ASSERT(tObj->WrapT==GL_REPEAT);
ASSERT(img->Format==GL_RGBA);
for (i = 0; i < n; i++) {
- const GLint col = IFLOOR(s[i] * width) & colMask;
- const GLint row = IFLOOR(t[i] * height) & rowMask;
+ const GLint col = IFLOOR(texcoords[i][0] * width) & colMask;
+ const GLint row = IFLOOR(texcoords[i][1] * height) & rowMask;
const GLint pos = (row << shift) | col;
const GLchan *texel = ((GLchan *) img->Data) + (pos << 2); /* pos*4 */
COPY_CHAN4(rgba[i], texel);
static void
sample_lambda_2d( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj,
- GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
+ GLuint n, GLfloat texcoords[][3],
+ const GLfloat lambda[],
GLchan rgba[][4] )
{
const GLfloat minMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit];
GLuint i;
- (void) u;
#ifdef DEBUG
ASSERT (span_is_monotonous(n, lambda) == GL_TRUE);
img->Border == 0) {
switch (img->Format) {
case GL_RGB:
- opt_sample_rgb_2d(ctx, texUnit, tObj, n, s, t, NULL,
+ opt_sample_rgb_2d(ctx, texUnit, tObj, n, texcoords,
NULL, rgba);
break;
case GL_RGBA:
- opt_sample_rgba_2d(ctx, texUnit, tObj, n, s, t, NULL,
+ opt_sample_rgba_2d(ctx, texUnit, tObj, n, texcoords,
NULL, rgba);
break;
default:
- sample_nearest_2d(ctx, texUnit, tObj, n, s, t, NULL,
+ sample_nearest_2d(ctx, texUnit, tObj, n, texcoords,
NULL, rgba);
}
}
else {
- sample_nearest_2d(ctx, texUnit, tObj, n, s, t, NULL,
+ sample_nearest_2d(ctx, texUnit, tObj, n, texcoords,
NULL, rgba);
}
break;
case GL_LINEAR:
- sample_linear_2d(ctx, texUnit, tObj, n, s, t, NULL,
+ sample_linear_2d(ctx, texUnit, tObj, n, texcoords,
NULL, rgba);
break;
default:
switch (tObj->MinFilter) {
case GL_NEAREST:
sample_2d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
- s[i], t[i], rgba[i]);
+ texcoords[i][0], texcoords[i][1], rgba[i]);
break;
case GL_LINEAR:
sample_2d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
- s[i], t[i], rgba[i]);
+ texcoords[i][0], texcoords[i][1], rgba[i]);
break;
case GL_NEAREST_MIPMAP_NEAREST:
- sample_2d_nearest_mipmap_nearest(ctx, tObj, s[i], t[i],
+ sample_2d_nearest_mipmap_nearest(ctx, tObj, texcoords[i][0], texcoords[i][1],
lambda[i], rgba[i]);
break;
case GL_LINEAR_MIPMAP_NEAREST:
- sample_2d_linear_mipmap_nearest(ctx,tObj, s[i], t[i],
+ sample_2d_linear_mipmap_nearest(ctx,tObj, texcoords[i][0], texcoords[i][1],
lambda[i], rgba[i]);
break;
case GL_NEAREST_MIPMAP_LINEAR:
- sample_2d_nearest_mipmap_linear(ctx,tObj, s[i], t[i],
+ sample_2d_nearest_mipmap_linear(ctx,tObj, texcoords[i][0], texcoords[i][1],
lambda[i], rgba[i]);
break;
case GL_LINEAR_MIPMAP_LINEAR:
- sample_2d_linear_mipmap_linear(ctx,tObj, s[i], t[i],
+ sample_2d_linear_mipmap_linear(ctx,tObj, texcoords[i][0], texcoords[i][1],
lambda[i], rgba[i] );
break;
default:
switch (tObj->MagFilter) {
case GL_NEAREST:
sample_2d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
- s[i], t[i], rgba[i]);
+ texcoords[i][0], texcoords[i][1], rgba[i]);
break;
case GL_LINEAR:
sample_2d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
- s[i], t[i], rgba[i] );
+ texcoords[i][0], texcoords[i][1], rgba[i] );
break;
default:
_mesa_problem(NULL, "Bad mag filter in sample_2d_texture");
static void
sample_nearest_3d(GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
+ GLfloat texcoords[][3], const GLfloat lambda[],
GLchan rgba[][4])
{
GLuint i;
struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
(void) lambda;
for (i=0;i<n;i++) {
- sample_3d_nearest(ctx, tObj, image, s[i], t[i], u[i], rgba[i]);
+ sample_3d_nearest(ctx, tObj, image, texcoords[i][0], texcoords[i][1], texcoords[i][2], rgba[i]);
}
}
static void
sample_linear_3d( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
- GLchan rgba[][4] )
+ GLfloat texcoords[][3],
+ const GLfloat lambda[], GLchan rgba[][4] )
{
GLuint i;
struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
(void) lambda;
for (i=0;i<n;i++) {
- sample_3d_linear(ctx, tObj, image, s[i], t[i], u[i], rgba[i]);
+ sample_3d_linear(ctx, tObj, image, texcoords[i][0], texcoords[i][1], texcoords[i][2], rgba[i]);
}
}
static void
sample_lambda_3d( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
+ GLfloat texcoords[][3], const GLfloat lambda[],
GLchan rgba[][4] )
{
GLuint i;
switch (tObj->MinFilter) {
case GL_NEAREST:
sample_3d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
- s[i], t[i], u[i], rgba[i]);
+ texcoords[i][0], texcoords[i][1], texcoords[i][2], rgba[i]);
break;
case GL_LINEAR:
sample_3d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
- s[i], t[i], u[i], rgba[i]);
+ texcoords[i][0], texcoords[i][1], texcoords[i][2], rgba[i]);
break;
case GL_NEAREST_MIPMAP_NEAREST:
- sample_3d_nearest_mipmap_nearest(ctx, tObj, s[i], t[i], u[i],
+ sample_3d_nearest_mipmap_nearest(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
lambda[i], rgba[i]);
break;
case GL_LINEAR_MIPMAP_NEAREST:
- sample_3d_linear_mipmap_nearest(ctx, tObj, s[i], t[i], u[i],
+ sample_3d_linear_mipmap_nearest(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
lambda[i], rgba[i]);
break;
case GL_NEAREST_MIPMAP_LINEAR:
- sample_3d_nearest_mipmap_linear(ctx, tObj, s[i], t[i], u[i],
+ sample_3d_nearest_mipmap_linear(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
lambda[i], rgba[i]);
break;
case GL_LINEAR_MIPMAP_LINEAR:
- sample_3d_linear_mipmap_linear(ctx, tObj, s[i], t[i], u[i],
+ sample_3d_linear_mipmap_linear(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
lambda[i], rgba[i]);
break;
default:
switch (tObj->MagFilter) {
case GL_NEAREST:
sample_3d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
- s[i], t[i], u[i], rgba[i]);
+ texcoords[i][0], texcoords[i][1], texcoords[i][2], rgba[i]);
break;
case GL_LINEAR:
sample_3d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
- s[i], t[i], u[i], rgba[i]);
+ texcoords[i][0], texcoords[i][1], texcoords[i][2], rgba[i]);
break;
default:
_mesa_problem(NULL, "Bad mag filter in sample_3d_texture");
static void
sample_nearest_cube(GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
+ GLfloat texcoords[][3], const GLfloat lambda[],
GLchan rgba[][4])
{
GLuint i;
for (i = 0; i < n; i++) {
const struct gl_texture_image **images;
GLfloat newS, newT;
- images = choose_cube_face(tObj, s[i], t[i], u[i], &newS, &newT);
+ images = choose_cube_face(tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2], &newS, &newT);
sample_2d_nearest(ctx, tObj, images[tObj->BaseLevel],
newS, newT, rgba[i]);
}
static void
sample_linear_cube(GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
- GLchan rgba[][4])
+ GLfloat texcoords[][3],
+ const GLfloat lambda[], GLchan rgba[][4])
{
GLuint i;
(void) lambda;
for (i = 0; i < n; i++) {
const struct gl_texture_image **images;
GLfloat newS, newT;
- images = choose_cube_face(tObj, s[i], t[i], u[i], &newS, &newT);
+ images = choose_cube_face(tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2], &newS, &newT);
sample_2d_linear(ctx, tObj, images[tObj->BaseLevel],
newS, newT, rgba[i]);
}
static void
sample_lambda_cube( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
+ GLfloat texcoords[][3], const GLfloat lambda[],
GLchan rgba[][4])
{
GLfloat MinMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit];
{
const struct gl_texture_image **images;
GLfloat newS, newT;
- images = choose_cube_face(tObj, s[i], t[i], u[i],
+ images = choose_cube_face(tObj, texcoords[i][0],
+ texcoords[i][1], texcoords[i][2],
&newS, &newT);
sample_2d_nearest(ctx, tObj, images[tObj->BaseLevel],
newS, newT, rgba[i]);
{
const struct gl_texture_image **images;
GLfloat newS, newT;
- images = choose_cube_face(tObj, s[i], t[i], u[i],
+ images = choose_cube_face(tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
&newS, &newT);
sample_2d_linear(ctx, tObj, images[tObj->BaseLevel],
newS, newT, rgba[i]);
}
break;
case GL_NEAREST_MIPMAP_NEAREST:
- sample_cube_nearest_mipmap_nearest(ctx, tObj, s[i], t[i], u[i],
+ sample_cube_nearest_mipmap_nearest(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
lambda[i], rgba[i]);
break;
case GL_LINEAR_MIPMAP_NEAREST:
- sample_cube_linear_mipmap_nearest(ctx, tObj, s[i], t[i], u[i],
+ sample_cube_linear_mipmap_nearest(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
lambda[i], rgba[i]);
break;
case GL_NEAREST_MIPMAP_LINEAR:
- sample_cube_nearest_mipmap_linear(ctx, tObj, s[i], t[i], u[i],
+ sample_cube_nearest_mipmap_linear(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
lambda[i], rgba[i]);
break;
case GL_LINEAR_MIPMAP_LINEAR:
- sample_cube_linear_mipmap_linear(ctx, tObj, s[i], t[i], u[i],
+ sample_cube_linear_mipmap_linear(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
lambda[i], rgba[i]);
break;
default:
/* magnification */
const struct gl_texture_image **images;
GLfloat newS, newT;
- images = choose_cube_face(tObj, s[i], t[i], u[i],
+ images = choose_cube_face(tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
&newS, &newT);
switch (tObj->MagFilter) {
case GL_NEAREST:
static void
null_sample_func( GLcontext *ctx, GLuint texUnit,
const struct gl_texture_object *tObj, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat u[], const GLfloat lambda[],
+ GLfloat texcoords[][3], const GLfloat lambda[],
GLchan rgba[][4])
{
}
static void
sample_depth_texture(const GLcontext *ctx,
const struct gl_texture_unit *texUnit,
- GLuint n,
- const GLfloat s[], const GLfloat t[], const GLfloat r[],
+ GLuint n, GLfloat texcoords[][3],
GLchan texel[][4])
{
const struct gl_texture_object *texObj = texUnit->_Current;
for (i = 0; i < n; i++) {
GLfloat depthSample;
GLint col, row;
- COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapS, s[i], width, col);
- COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapT, t[i], height, row);
+ COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapS, texcoords[i][0], width, col);
+ COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapT, texcoords[i][1], height, row);
depthSample = *((const GLfloat *) texImage->Data + row * width + col);
- if ((r[i] <= depthSample && lequal) ||
- (r[i] >= depthSample && gequal)) {
+ if ((texcoords[i][2] <= depthSample && lequal) ||
+ (texcoords[i][2] >= depthSample && gequal)) {
result = CHAN_MAX;
}
else {
GLfloat u, v;
GLuint useBorderTexel;
- COMPUTE_LINEAR_TEXEL_LOCATIONS(texObj->WrapS, s[i], u, width, i0, i1);
- COMPUTE_LINEAR_TEXEL_LOCATIONS(texObj->WrapT, t[i], v, height,j0, j1);
+ COMPUTE_LINEAR_TEXEL_LOCATIONS(texObj->WrapS, texcoords[i][0], u, width, i0, i1);
+ COMPUTE_LINEAR_TEXEL_LOCATIONS(texObj->WrapT, texcoords[i][1], v, height,j0, j1);
useBorderTexel = 0;
if (texImage->Border) {
const GLfloat w11 = ( a) * ( b);
const GLfloat depthSample = w00 * depth00 + w10 * depth10
+ w01 * depth01 + w11 * depth11;
- if ((depthSample <= r[i] && lequal) ||
- (depthSample >= r[i] && gequal)) {
+ if ((depthSample <= texcoords[i][2] && lequal) ||
+ (depthSample >= texcoords[i][2] && gequal)) {
result = ambient;
}
else {
const GLfloat d = (CHAN_MAXF - (GLfloat) ambient) * 0.25F;
GLfloat luminance = CHAN_MAXF;
if (lequal) {
- if (depth00 <= r[i]) luminance -= d;
- if (depth01 <= r[i]) luminance -= d;
- if (depth10 <= r[i]) luminance -= d;
- if (depth11 <= r[i]) luminance -= d;
+ if (depth00 <= texcoords[i][2]) luminance -= d;
+ if (depth01 <= texcoords[i][2]) luminance -= d;
+ if (depth10 <= texcoords[i][2]) luminance -= d;
+ if (depth11 <= texcoords[i][2]) luminance -= d;
}
else {
- if (depth00 >= r[i]) luminance -= d;
- if (depth01 >= r[i]) luminance -= d;
- if (depth10 >= r[i]) luminance -= d;
- if (depth11 >= r[i]) luminance -= d;
+ if (depth00 >= texcoords[i][2]) luminance -= d;
+ if (depth01 >= texcoords[i][2]) luminance -= d;
+ if (depth10 >= texcoords[i][2]) luminance -= d;
+ if (depth11 >= texcoords[i][2]) luminance -= d;
}
result = (GLchan) luminance;
}
static void
sample_depth_texture2(const GLcontext *ctx,
const struct gl_texture_unit *texUnit,
- GLuint n,
- const GLfloat s[], const GLfloat t[], const GLfloat r[],
+ GLuint n, GLfloat texcoords[][3],
GLchan texel[][4])
{
const struct gl_texture_object *texObj = texUnit->_Current;
GLint col, row, ii, jj, imin, imax, jmin, jmax, samples, count;
GLfloat w;
GLchan lum;
- COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapS, s[i], width, col);
- COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapT, t[i], height, row);
+ COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapS, texcoords[i][0],
+ width, col);
+ COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapT, texcoords[i][1],
+ height, row);
imin = col - K;
imax = col + K;
* Apply a unit of texture mapping to the incoming fragments.
*/
void
-_swrast_texture_fragments( GLcontext *ctx, GLuint texUnit, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat r[], GLfloat lambda[],
- CONST GLchan primary_rgba[][4], GLchan rgba[][4] )
+_old_swrast_texture_fragments( GLcontext *ctx, GLuint texUnit, GLuint n,
+ GLfloat texcoords[][3], GLfloat lambda[],
+ CONST GLchan primary_rgba[][4],
+ GLchan rgba[][4] )
{
const GLuint mask = TEXTURE0_ANY << (texUnit * 4);
if (ctx->Texture._ReallyEnabled & mask) {
const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
-
+
if (textureUnit->_Current) { /* XXX need this? */
const struct gl_texture_object *curObj = textureUnit->_Current;
GLchan texel[PB_SIZE][4];
-
+
if (textureUnit->LodBias != 0.0F) {
/* apply LOD bias, but don't clamp yet */
GLuint i;
lambda[i] += textureUnit->LodBias;
}
}
-
+
if ((curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0)
&& lambda) {
/* apply LOD clamping to lambda */
/* Sample the texture. */
if (curObj->Image[curObj->BaseLevel]->Format == GL_DEPTH_COMPONENT) {
/* depth texture */
- sample_depth_texture(ctx, textureUnit, n, s, t, r, texel);
+ sample_depth_texture(ctx, textureUnit, n, texcoords, texel);
}
else {
/* color texture */
SWRAST_CONTEXT(ctx)->TextureSample[texUnit]( ctx, texUnit,
textureUnit->_Current,
- n, s, t, r,
+ n, texcoords,
lambda, texel );
}
apply_texture( ctx, textureUnit, n, primary_rgba,
}
}
}
+
+
+/*
+ * Apply a unit of texture mapping to the incoming fragments.
+ */
+void
+_swrast_texture_fragments( GLcontext *ctx, GLuint texUnit,
+ struct sw_span *span,
+ GLchan rgba[][4] )
+{
+ const GLuint mask = TEXTURE0_ANY << (texUnit * 4);
+
+ if (ctx->Texture._ReallyEnabled & mask) {
+ const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
+ GLfloat *lambda = span->lambda[texUnit];
+
+ ASSERT(span->filledTex[texUnit] == GL_TRUE);
+
+ if (textureUnit->_Current) { /* XXX need this? */
+ const struct gl_texture_object *curObj = textureUnit->_Current;
+ GLchan texel[PB_SIZE][4];
+
+ if (textureUnit->LodBias != 0.0F) {
+ /* apply LOD bias, but don't clamp yet */
+ GLuint i;
+ for (i=0;i<span->end;i++) {
+ lambda[i] += textureUnit->LodBias;
+ }
+ }
+
+ if ((curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0)
+ && lambda) {
+ /* apply LOD clamping to lambda */
+ const GLfloat min = curObj->MinLod;
+ const GLfloat max = curObj->MaxLod;
+ GLuint i;
+ for (i=0;i<span->end;i++) {
+ GLfloat l = lambda[i];
+ lambda[i] = CLAMP(l, min, max);
+ }
+ }
+
+ /* Sample the texture. */
+ if (curObj->Image[curObj->BaseLevel]->Format == GL_DEPTH_COMPONENT) {
+ /* depth texture */
+ sample_depth_texture(ctx, textureUnit, span->end,
+ span->texcoords[texUnit], texel);
+ }
+ else {
+ /* color texture */
+ SWRAST_CONTEXT(ctx)->TextureSample[texUnit]( ctx, texUnit,
+ textureUnit->_Current,
+ span->end,
+ span->texcoords[texUnit],
+ lambda, texel );
+ }
+ apply_texture( ctx, textureUnit, span->end,
+ (CONST GLchan (*)[4])span->color.rgba,
+ (CONST GLchan (*)[4]) texel, rgba );
+ }
+ }
+}
+
+
-/* $Id: s_texture.h,v 1.6 2001/03/12 00:48:42 gareth Exp $ */
+/* $Id: s_texture.h,v 1.7 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
extern void
-_swrast_texture_fragments( GLcontext *ctx, GLuint texSet, GLuint n,
- const GLfloat s[], const GLfloat t[],
- const GLfloat r[], GLfloat lambda[],
- CONST GLchan primary_rgba[][4], GLchan rgba[][4] );
+_swrast_texture_fragments( GLcontext *ctx, GLuint texSet,
+ struct sw_span *span,
+ GLchan rgba[][4] );
+
+extern void
+_old_swrast_texture_fragments( GLcontext *ctx, GLuint texSet, GLuint n,
+ GLfloat texcoords[][3], GLfloat lambda[],
+ CONST GLchan primary_rgba[][4], GLchan rgba[][4] );
#endif
-/* $Id: s_trispan.h,v 1.3 2001/09/13 22:12:54 brianp Exp $ */
+/* $Id: s_trispan.h,v 1.4 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
#define S_TRISPAN_H
-/*
- * The triangle_span structure is used by the triangle template code in
- * s_tritemp.h. It describes how colors, Z, texcoords, etc are to be
- * interpolated across each scanline of triangle.
- * With this structure it's easy to hand-off span rasterization to a
- * subroutine instead of doing it all inline like we used to do.
- * It also cleans up the local variable namespace a great deal.
- *
- * It would be interesting to experiment with multiprocessor rasterization
- * with this structure. The triangle rasterizer could simply emit a
- * stream of these structures which would be consumed by one or more
- * span-processing threads which could run in parallel.
- */
-
-
-/* When the triangle_span struct is initialized, these flags indicates
- * which values are needed for rendering the triangle.
- */
-#define SPAN_RGBA 0x001
-#define SPAN_SPEC 0x002
-#define SPAN_INDEX 0x004
-#define SPAN_Z 0x008
-#define SPAN_FOG 0x010
-#define SPAN_TEXTURE 0x020
-#define SPAN_INT_TEXTURE 0x040
-#define SPAN_LAMBDA 0x080
-#define SPAN_FLAT 0x100 /* flat shading? */
-
-
-struct triangle_span {
- GLint x, y;
- GLuint count;
- GLuint activeMask; /* OR of the SPAN_* flags */
-#if CHAN_TYPE == GL_FLOAT
- GLfloat red, redStep;
- GLfloat green, greenStep;
- GLfloat blue, blueStep;
- GLfloat alpha, alphaStep;
- GLfloat specRed, specRedStep;
- GLfloat specGreen, specGreenStep;
- GLfloat specBlue, specBlueStep;
-#else
- GLfixed red, redStep;
- GLfixed green, greenStep;
- GLfixed blue, blueStep;
- GLfixed alpha, alphaStep;
- GLfixed specRed, specRedStep;
- GLfixed specGreen, specGreenStep;
- GLfixed specBlue, specBlueStep;
-#endif
- GLfixed index, indexStep;
- GLfixed z, zStep;
- GLfloat fog, fogStep;
- GLfloat tex[MAX_TEXTURE_UNITS][4], texStep[MAX_TEXTURE_UNITS][4];
- GLfixed intTex[2], intTexStep[2];
- /* Needed for texture lambda (LOD) computation */
- GLfloat rho[MAX_TEXTURE_UNITS];
- GLfloat texWidth[MAX_TEXTURE_UNITS], texHeight[MAX_TEXTURE_UNITS];
-};
-
-
#endif /* S_TRISPAN_H */
-/* $Id: s_tritemp.h,v 1.28 2001/12/05 10:24:31 keithw Exp $ */
+/* $Id: s_tritemp.h,v 1.29 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
const GLint snapMask = ~((FIXED_ONE / 16) - 1); /* for x/y coord snapping */
GLfixed vMin_fx, vMin_fy, vMid_fx, vMid_fy, vMax_fx, vMax_fy;
- struct triangle_span span;
+ struct sw_span span;
#ifdef INTERP_Z
(void) fixedToDepthShift;
/* initialize the span interpolants to the leftmost value */
/* ff = fixed-pt fragment */
const GLint right = FixedToInt(fxRightEdge);
+ SW_SPAN_RESET(span);
span.x = FixedToInt(fxLeftEdge);
+
if (right <= span.x)
- span.count = 0;
+ span.end = 0;
else
- span.count = right - span.x;
+ span.end = right - span.x;
#ifdef INTERP_Z
span.z = fz;
#endif
/* This is where we actually generate fragments */
- if (span.count > 0) {
+ if (span.end > 0) {
RENDER_SPAN( span );
}
-/* $Id: s_zoom.c,v 1.6 2001/05/15 21:30:27 brianp Exp $ */
+/* $Id: s_zoom.c,v 1.7 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
return;
}
- assert( m <= MAX_WIDTH );
+ ASSERT( m <= MAX_WIDTH );
/* zoom the span horizontally */
if (ctx->Pixel.ZoomX==-1.0F) {
/* write the span */
for (r=r0; r<r1; r++) {
- _mesa_write_rgba_span( ctx, m, x+skipcol, r, zdepth,
+ _old_write_rgba_span( ctx, m, x+skipcol, r, zdepth,
(fog ? zfog : 0), zrgba, NULL, GL_BITMAP );
}
}
return;
}
- assert( m <= MAX_WIDTH );
+ ASSERT( m <= MAX_WIDTH );
/* zoom the span horizontally */
if (ctx->Pixel.ZoomX==-1.0F) {
/* write the span */
for (r=r0; r<r1; r++) {
- _mesa_write_rgba_span( ctx, m, x+skipcol, r, zdepth,
+ _old_write_rgba_span( ctx, m, x+skipcol, r, zdepth,
(fog ? zfog : 0), zrgba, NULL, GL_BITMAP );
}
}
return;
}
- assert( m <= MAX_WIDTH );
+ ASSERT( m <= MAX_WIDTH );
/* zoom the span horizontally */
if (ctx->Pixel.ZoomX==-1.0F) {
/* write the span */
for (r=r0; r<r1; r++) {
- _mesa_write_index_span( ctx, m, x+skipcol, r, zdepth,
+ _old_write_index_span( ctx, m, x+skipcol, r, zdepth,
(fog ? zfog : 0), zindexes, NULL, GL_BITMAP );
}
}
return;
}
- assert( m <= MAX_WIDTH );
+ ASSERT( m <= MAX_WIDTH );
/* zoom the span horizontally */
if (ctx->Pixel.ZoomX==-1.0F) {
-/* $Id: swrast.h,v 1.12 2001/03/19 02:25:36 keithw Exp $ */
+/* $Id: swrast.h,v 1.13 2001/12/17 04:54:35 brianp Exp $ */
/*
* Mesa 3-D graphics library
} SWvertex;
+/*
+ * The sw_span structure is used by the triangle template code in
+ * s_tritemp.h. It describes how colors, Z, texcoords, etc are to be
+ * interpolated across each scanline of triangle.
+ * With this structure it's easy to hand-off span rasterization to a
+ * subroutine instead of doing it all inline like we used to do.
+ * It also cleans up the local variable namespace a great deal.
+ *
+ * It would be interesting to experiment with multiprocessor rasterization
+ * with this structure. The triangle rasterizer could simply emit a
+ * stream of these structures which would be consumed by one or more
+ * span-processing threads which could run in parallel.
+ */
+
+
+/* When the sw_span struct is initialized, these flags indicates
+ * which values are needed for rendering the triangle.
+ */
+#define SPAN_RGBA 0x001
+#define SPAN_SPEC 0x002
+#define SPAN_INDEX 0x004
+#define SPAN_Z 0x008
+#define SPAN_FOG 0x010
+#define SPAN_TEXTURE 0x020
+#define SPAN_INT_TEXTURE 0x040
+#define SPAN_LAMBDA 0x080
+#define SPAN_FLAT 0x100 /* flat shading? */
+
+
+struct sw_span {
+ GLint x, y;
+ GLuint start, end; /* start=first pixel in span, end=last pixel in span*/
+ /* only end is used until now.(end was before called count) */
+ GLuint activeMask; /* OR of the SPAN_* flags */
+#if CHAN_TYPE == GL_FLOAT
+ GLfloat red, redStep;
+ GLfloat green, greenStep;
+ GLfloat blue, blueStep;
+ GLfloat alpha, alphaStep;
+ GLfloat specRed, specRedStep;
+ GLfloat specGreen, specGreenStep;
+ GLfloat specBlue, specBlueStep;
+#else /* CHAN_TYPE == */
+ GLfixed red, redStep;
+ GLfixed green, greenStep;
+ GLfixed blue, blueStep;
+ GLfixed alpha, alphaStep;
+ GLfixed specRed, specRedStep;
+ GLfixed specGreen, specGreenStep;
+ GLfixed specBlue, specBlueStep;
+#endif
+ GLfixed index, indexStep;
+ GLfixed z, zStep;
+ GLfloat fog, fogStep;
+ GLfloat tex[MAX_TEXTURE_UNITS][4], texStep[MAX_TEXTURE_UNITS][4];
+ GLfixed intTex[2], intTexStep[2];
+ /* Needed for texture lambda (LOD) computation */
+ GLfloat rho[MAX_TEXTURE_UNITS];
+ GLfloat texWidth[MAX_TEXTURE_UNITS], texHeight[MAX_TEXTURE_UNITS];
+
+ GLboolean write_all; /* This flag indicates that only a part of */
+ /*the span is visible. */
+#ifdef DEBUG
+ GLboolean filledDepth, filledMask, filledAlpha;
+ GLboolean filledColor, filledSpecular;
+ GLboolean filledLambda[MAX_TEXTURE_UNITS], filledTex[MAX_TEXTURE_UNITS];
+ GLboolean testedDepth, testedAlpha;
+#endif
+ /* The interpolated fragment values */
+ GLdepth depth[MAX_WIDTH];
+ union {
+ GLchan rgb[MAX_WIDTH][3];
+ GLchan rgba[MAX_WIDTH][4];
+ GLuint index[MAX_WIDTH];
+ } color;
+ GLchan specular[MAX_WIDTH][4];
+ GLint itexcoords[MAX_WIDTH][2]; /* s, t */
+ GLfloat texcoords[MAX_TEXTURE_UNITS][MAX_WIDTH][3]; /* s, t, r */
+ GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH];
+ GLfloat coverage[MAX_WIDTH];
+ GLubyte mask[MAX_WIDTH];
+};
+
+#ifdef DEBUG
+#define SW_SPAN_SET_FLAG(flag) {ASSERT((flag) == GL_FALSE);(flag) = GL_TRUE;}
+#define SW_SPAN_RESET(span) { \
+ (span).filledDepth = (span).filledMask = (span).filledAlpha \
+ = (span).filledColor = (span).filledSpecular \
+ = (span).testedDepth = (span).testedAlpha = GL_FALSE; \
+ MEMSET((span).filledTex, GL_FALSE, \
+ MAX_TEXTURE_UNITS*sizeof(GLboolean)); \
+ MEMSET((span).filledLambda, GL_FALSE, \
+ MAX_TEXTURE_UNITS*sizeof(GLboolean)); \
+ (span).start = 0; (span).write_all = GL_TRUE;}
+#else
+#define SW_SPAN_SET_FLAG(flag) ;
+#define SW_SPAN_RESET(span) {(span).start = 0;(span).write_all = GL_TRUE;}
+#endif
+
struct swrast_device_driver;
projects / mesa.git / commitdiff