-/* $Id: s_pointtemp.h,v 1.16 2002/05/27 17:04:53 brianp Exp $ */
-
/*
* Mesa 3-D graphics library
- * Version: 4.1
+ * Version: 6.0
*
- * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
+/*
+ * Regarding GL_NV_point_sprite:
+ *
+ * Portions of this software may use or implement intellectual
+ * property owned and licensed by NVIDIA Corporation. NVIDIA disclaims
+ * any and all warranties with respect to such intellectual property,
+ * including any use thereof or modifications thereto.
+ */
+
/*
* Point rendering template code.
* SPECULAR = do separate specular color
* LARGE = do points with diameter > 1 pixel
* ATTENUATE = compute point size attenuation
- * SPRITE = GL_NV_point_sprite
+ * SPRITE = GL_ARB_point_sprite / GL_NV_point_sprite
*
* Notes: LARGE and ATTENUATE are exclusive of each other.
* TEXTURE requires RGBA
static void
NAME ( GLcontext *ctx, const SWvertex *vert )
{
-#if FLAGS & TEXTURE
- GLuint u;
-#endif
#if FLAGS & (ATTENUATE | LARGE | SMOOTH | SPRITE)
GLfloat size;
#endif
-#if FLAGS & ATTENUATE
+#if FLAGS & RGBA
+#if (FLAGS & ATTENUATE) && (FLAGS & SMOOTH)
GLfloat alphaAtten;
#endif
-#if (FLAGS & RGBA) && (FLAGS & SMOOTH)
const GLchan red = vert->color[0];
const GLchan green = vert->color[1];
const GLchan blue = vert->color[2];
const GLchan alpha = vert->color[3];
#endif
-
- struct sw_span *span = SWRAST_CONTEXT(ctx)->span;
+#if FLAGS & SPECULAR
+ const GLchan specRed = vert->specular[0];
+ const GLchan specGreen = vert->specular[1];
+ const GLchan specBlue = vert->specular[2];
+#endif
+#if FLAGS & INDEX
+ const GLuint colorIndex = vert->index;
+#endif
+#if FLAGS & TEXTURE
+ GLfloat texcoord[MAX_TEXTURE_COORD_UNITS][4];
+ GLuint u;
+#endif
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ struct sw_span *span = &(swrast->PointSpan);
/* Cull primitives with malformed coordinates.
*/
return;
}
- INIT_SPAN(span, GL_POINT, 0, SPAN_FOG, SPAN_XY | SPAN_Z);
+ /*
+ * Span init
+ */
+ span->interpMask = SPAN_FOG;
+ span->arrayMask = SPAN_XY | SPAN_Z;
span->fog = vert->fog;
span->fogStep = 0.0;
-
-#if (FLAGS & RGBA)
-#if (FLAGS & SMOOTH)
- /* because we need per-fragment alpha values */
+#if FLAGS & RGBA
span->arrayMask |= SPAN_RGBA;
-#else
- /* same RGBA for all fragments */
- span->interpMask |= SPAN_RGBA;
- span->red = ChanToFixed(vert->color[0]);
- span->green = ChanToFixed(vert->color[1]);
- span->blue = ChanToFixed(vert->color[2]);
- span->alpha = ChanToFixed(vert->color[3]);
- span->redStep = span->greenStep = span->blueStep = span->alphaStep = 0;
-#endif /*SMOOTH*/
-#endif /*RGBA*/
+#endif
#if FLAGS & SPECULAR
- span->interpMask |= SPAN_SPEC;
- span->specRed = ChanToFixed(vert->specular[0]);
- span->specGreen = ChanToFixed(vert->specular[1]);
- span->specBlue = ChanToFixed(vert->specular[2]);
- span->specRedStep = span->specGreenStep = span->specBlueStep = 0;
+ span->arrayMask |= SPAN_SPEC;
#endif
#if FLAGS & INDEX
- span->interpMask |= SPAN_INDEX;
- span->index = IntToFixed(vert->index);
- span->indexStep = 0;
+ span->arrayMask |= SPAN_INDEX;
#endif
#if FLAGS & TEXTURE
- /* but not used for sprite mode */
- span->interpMask |= SPAN_TEXTURE;
+ span->arrayMask |= SPAN_TEXTURE;
for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
if (ctx->Texture.Unit[u]._ReallyEnabled) {
const GLfloat q = vert->texcoord[u][3];
- const GLfloat invQ = (q == 0.0 || q == 1.0) ? 1.0 : (1.0 / q);
- span->tex[u][0] = vert->texcoord[u][0] * invQ;
- span->tex[u][1] = vert->texcoord[u][1] * invQ;
- span->tex[u][2] = vert->texcoord[u][2] * invQ;
- span->tex[u][3] = q;
- span->texStepX[u][0] = span->texStepY[u][0] = 0.0;
- span->texStepX[u][1] = span->texStepY[u][1] = 0.0;
- span->texStepX[u][2] = span->texStepY[u][2] = 0.0;
- span->texStepX[u][3] = span->texStepY[u][3] = 0.0;
+ const GLfloat invQ = (q == 0.0F || q == 1.0F) ? 1.0F : (1.0F / q);
+ texcoord[u][0] = vert->texcoord[u][0] * invQ;
+ texcoord[u][1] = vert->texcoord[u][1] * invQ;
+ texcoord[u][2] = vert->texcoord[u][2] * invQ;
+ texcoord[u][3] = q;
}
}
#endif
#if FLAGS & ATTENUATE
if (vert->pointSize >= ctx->Point.Threshold) {
size = MIN2(vert->pointSize, ctx->Point.MaxSize);
+#if (FLAGS & RGBA) && (FLAGS & SMOOTH)
alphaAtten = 1.0F;
+#endif
}
else {
+#if (FLAGS & RGBA) && (FLAGS & SMOOTH)
GLfloat dsize = vert->pointSize / ctx->Point.Threshold;
- size = MAX2(ctx->Point.Threshold, ctx->Point.MinSize);
alphaAtten = dsize * dsize;
+#endif
+ size = MAX2(ctx->Point.Threshold, ctx->Point.MinSize);
}
#elif FLAGS & (LARGE | SMOOTH | SPRITE)
size = ctx->Point._Size;
#endif
-#if FLAGS & (LARGE | ATTENUATE | SMOOTH | SPRITE)
- {
+#if FLAGS & (ATTENUATE | LARGE | SMOOTH | SPRITE)
+ /*
+ * Multi-pixel points
+ */
+ {{
GLint x, y;
const GLfloat radius = 0.5F * size;
- const GLint z = (GLint) (vert->win[2]);
- GLuint count = 0;
+ const GLint z = (GLint) (vert->win[2] + 0.5F);
+ GLuint count;
#if FLAGS & SMOOTH
const GLfloat rmin = radius - 0.7071F; /* 0.7071 = sqrt(2)/2 */
const GLfloat rmax = radius + 0.7071F;
}
#endif /*SMOOTH*/
+ /* check if we need to flush */
+ if (span->end + (xmax-xmin+1) * (ymax-ymin+1) >= MAX_WIDTH ||
+ (swrast->_RasterMask & (BLEND_BIT | LOGIC_OP_BIT | MASKING_BIT))) {
+#if FLAGS & (TEXTURE | SPRITE)
+ if (ctx->Texture._EnabledUnits)
+ _swrast_write_texture_span(ctx, span);
+ else
+ _swrast_write_rgba_span(ctx, span);
+#elif FLAGS & RGBA
+ _swrast_write_rgba_span(ctx, span);
+#else
+ _swrast_write_index_span(ctx, span);
+#endif
+ span->end = 0;
+ }
+
+ /*
+ * OK, generate fragments
+ */
+ count = span->end;
(void) radius;
for (y = ymin; y <= ymax; y++) {
for (x = xmin; x <= xmax; x++) {
-#if FLAGS & SPRITE
+#if FLAGS & (SPRITE | TEXTURE)
GLuint u;
#endif
+
+#if FLAGS & RGBA
+ span->array->rgba[count][RCOMP] = red;
+ span->array->rgba[count][GCOMP] = green;
+ span->array->rgba[count][BCOMP] = blue;
+ span->array->rgba[count][ACOMP] = alpha;
+#endif
+#if FLAGS & SPECULAR
+ span->array->spec[count][RCOMP] = specRed;
+ span->array->spec[count][GCOMP] = specGreen;
+ span->array->spec[count][BCOMP] = specBlue;
+#endif
+#if FLAGS & INDEX
+ span->array->index[count] = colorIndex;
+#endif
+#if FLAGS & TEXTURE
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u]._ReallyEnabled) {
+ COPY_4V(span->array->texcoords[u][count], texcoord[u]);
+ }
+ }
+#endif
+
#if FLAGS & SMOOTH
/* compute coverage */
- const GLfloat dx = x - vert->win[0] + 0.5F;
- const GLfloat dy = y - vert->win[1] + 0.5F;
- const GLfloat dist2 = dx * dx + dy * dy;
- if (dist2 < rmax2) {
- if (dist2 >= rmin2) {
- /* compute partial coverage */
- span->coverage[count] = 1.0F - (dist2 - rmin2) * cscale;
+ {
+ const GLfloat dx = x - vert->win[0] + 0.5F;
+ const GLfloat dy = y - vert->win[1] + 0.5F;
+ const GLfloat dist2 = dx * dx + dy * dy;
+ if (dist2 < rmax2) {
+ if (dist2 >= rmin2) {
+ /* compute partial coverage */
+ span->array->coverage[count] = 1.0F - (dist2 - rmin2) * cscale;
#if FLAGS & INDEX
- span->coverage[count] *= 15.0; /* coverage in [0,15] */
+ /* coverage in [0,15] */
+ span->array->coverage[count] *= 15.0;
#endif
- }
- else {
- /* full coverage */
- span->coverage[count] = 1.0F;
- }
+ }
+ else {
+ /* full coverage */
+ span->array->coverage[count] = 1.0F;
+ }
- span->xArray[count] = x;
- span->yArray[count] = y;
- span->zArray[count] = z;
+ span->array->x[count] = x;
+ span->array->y[count] = y;
+ span->array->z[count] = z;
-#if FLAGS & RGBA
- span->color.rgba[count][RCOMP] = red;
- span->color.rgba[count][GCOMP] = green;
- span->color.rgba[count][BCOMP] = blue;
-#if FLAGS & ATTENUATE
- span->color.rgba[count][ACOMP] = (GLchan) (alpha * alphaAtten);
-#else
- span->color.rgba[count][ACOMP] = alpha;
+#if (FLAGS & ATTENUATE) && (FLAGS & RGBA)
+ span->array->rgba[count][ACOMP] = (GLchan) (alpha * alphaAtten);
+#elif FLAGS & RGBA
+ span->array->rgba[count][ACOMP] = alpha;
#endif /*ATTENUATE*/
-#endif /*RGBA*/
- count++;
- } /*if*/
+ count++;
+ } /*if*/
+ }
+
#else /*SMOOTH*/
+
/* not smooth (square points) */
- span->xArray[count] = x;
- span->yArray[count] = y;
- span->zArray[count] = z;
+ span->array->x[count] = x;
+ span->array->y[count] = y;
+ span->array->z[count] = z;
+
#if FLAGS & SPRITE
for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
if (ctx->Texture.Unit[u]._ReallyEnabled) {
if (ctx->Point.CoordReplace[u]) {
GLfloat s = 0.5F + (x + 0.5F - vert->win[0]) / size;
GLfloat t = 0.5F - (y + 0.5F - vert->win[1]) / size;
- span->texcoords[u][count][0] = s;
- span->texcoords[u][count][1] = t;
- span->texcoords[u][count][3] = 1.0F;
+ span->array->texcoords[u][count][0] = s;
+ span->array->texcoords[u][count][1] = t;
+ span->array->texcoords[u][count][3] = 1.0F;
if (ctx->Point.SpriteRMode == GL_ZERO)
- span->texcoords[u][count][2] = 0.0F;
+ span->array->texcoords[u][count][2] = 0.0F;
else if (ctx->Point.SpriteRMode == GL_S)
- span->texcoords[u][count][2] = vert->texcoord[u][0];
+ span->array->texcoords[u][count][2] = vert->texcoord[u][0];
else /* GL_R */
- span->texcoords[u][count][2] = vert->texcoord[u][2];
+ span->array->texcoords[u][count][2] = vert->texcoord[u][2];
}
else {
- COPY_4V(span->texcoords[u][count], vert->texcoord[u]);
+ COPY_4V(span->array->texcoords[u][count], vert->texcoord[u]);
}
}
}
#endif /*SPRITE*/
- count++;
+
+ count++; /* square point */
+
#endif /*SMOOTH*/
+
} /*for x*/
} /*for y*/
span->end = count;
- }
+ }}
#else /* LARGE | ATTENUATE | SMOOTH | SPRITE */
- {
- /* size == 1 */
- span->xArray[0] = (GLint) vert->win[0];
- span->yArray[0] = (GLint) vert->win[1];
- span->zArray[0] = (GLint) vert->win[2];
- span->end = 1;
- }
-
-#endif /* LARGE || ATTENUATE || SMOOTH */
-
- ASSERT(span->end > 0);
+ /*
+ * Single-pixel points
+ */
+ {{
+ GLuint count;
+ /* check if we need to flush */
+ if (span->end >= MAX_WIDTH ||
+ (swrast->_RasterMask & (BLEND_BIT | LOGIC_OP_BIT | MASKING_BIT))) {
#if FLAGS & (TEXTURE | SPRITE)
- if (ctx->Texture._ReallyEnabled)
- _mesa_write_texture_span(ctx, span);
- else
- _mesa_write_rgba_span(ctx, span);
+ if (ctx->Texture._EnabledUnits)
+ _swrast_write_texture_span(ctx, span);
+ else
+ _swrast_write_rgba_span(ctx, span);
#elif FLAGS & RGBA
- _mesa_write_rgba_span(ctx, span);
+ _swrast_write_rgba_span(ctx, span);
#else
- _mesa_write_index_span(ctx, span);
+ _swrast_write_index_span(ctx, span);
+#endif
+ span->end = 0;
+ }
+
+ count = span->end;
+
+#if FLAGS & RGBA
+ span->array->rgba[count][RCOMP] = red;
+ span->array->rgba[count][GCOMP] = green;
+ span->array->rgba[count][BCOMP] = blue;
+ span->array->rgba[count][ACOMP] = alpha;
#endif
+#if FLAGS & SPECULAR
+ span->array->spec[count][RCOMP] = specRed;
+ span->array->spec[count][GCOMP] = specGreen;
+ span->array->spec[count][BCOMP] = specBlue;
+#endif
+#if FLAGS & INDEX
+ span->array->index[count] = colorIndex;
+#endif
+#if FLAGS & TEXTURE
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u]._ReallyEnabled) {
+ COPY_4V(span->array->texcoords[u][count], texcoord[u]);
+ }
+ }
+#endif
+
+ span->array->x[count] = (GLint) vert->win[0];
+ span->array->y[count] = (GLint) vert->win[1];
+ span->array->z[count] = (GLint) (vert->win[2] + 0.5F);
+ span->end = count + 1;
+ }}
+
+#endif /* LARGE || ATTENUATE || SMOOTH */
+
+ ASSERT(span->end <= MAX_WIDTH);
}
projects / mesa.git / blobdiff