/* $Id: s_pointtemp.h,v 1.16 2002/05/27 17:04:53 brianp Exp $ */ /* * Mesa 3-D graphics library * Version: 4.1 * * Copyright (C) 1999-2002 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"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* * Point rendering template code. * * Set FLAGS = bitwise-OR of the following tokens: * * RGBA = do rgba instead of color index * SMOOTH = do antialiasing * TEXTURE = do texture coords * SPECULAR = do separate specular color * LARGE = do points with diameter > 1 pixel * ATTENUATE = compute point size attenuation * SPRITE = GL_NV_point_sprite * * Notes: LARGE and ATTENUATE are exclusive of each other. * TEXTURE requires RGBA * SPECULAR requires TEXTURE */ /* * NOTES on antialiased point rasterization: * * Let d = distance of fragment center from vertex. * if d < rmin2 then * fragment has 100% coverage * else if d > rmax2 then * fragment has 0% coverage * else * fragment has % coverage = (d - rmin2) / (rmax2 - rmin2) */ static void NAME ( GLcontext *ctx, const SWvertex *vert ) { #if FLAGS & TEXTURE GLuint u; #endif #if FLAGS & (ATTENUATE | LARGE | SMOOTH | SPRITE) GLfloat size; #endif #if FLAGS & ATTENUATE GLfloat alphaAtten; #endif #if (FLAGS & RGBA) && (FLAGS & SMOOTH) 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; /* Cull primitives with malformed coordinates. */ { float tmp = vert->win[0] + vert->win[1]; if (IS_INF_OR_NAN(tmp)) return; } INIT_SPAN(span, GL_POINT, 0, SPAN_FOG, SPAN_XY | SPAN_Z); span->fog = vert->fog; span->fogStep = 0.0; #if (FLAGS & RGBA) #if (FLAGS & SMOOTH) /* because we need per-fragment alpha values */ span->arrayMask |= SPAN_RGBA; #else /* same RGBA for all fragments */ span->interpMask |= SPAN_RGBA; span->red = ChanToFixed(vert->color[0]); span->green = ChanToFixed(vert->color[1]); span->blue = ChanToFixed(vert->color[2]); span->alpha = ChanToFixed(vert->color[3]); span->redStep = span->greenStep = span->blueStep = span->alphaStep = 0; #endif /*SMOOTH*/ #endif /*RGBA*/ #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; #endif #if FLAGS & INDEX span->interpMask |= SPAN_INDEX; span->index = IntToFixed(vert->index); span->indexStep = 0; #endif #if FLAGS & TEXTURE /* but not used for sprite mode */ span->interpMask |= 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; } } #endif #if FLAGS & SMOOTH span->arrayMask |= SPAN_COVERAGE; #endif #if FLAGS & SPRITE span->arrayMask |= SPAN_TEXTURE; #endif #if FLAGS & ATTENUATE if (vert->pointSize >= ctx->Point.Threshold) { size = MIN2(vert->pointSize, ctx->Point.MaxSize); alphaAtten = 1.0F; } else { GLfloat dsize = vert->pointSize / ctx->Point.Threshold; size = MAX2(ctx->Point.Threshold, ctx->Point.MinSize); alphaAtten = dsize * dsize; } #elif FLAGS & (LARGE | SMOOTH | SPRITE) size = ctx->Point._Size; #endif #if FLAGS & (LARGE | ATTENUATE | SMOOTH | SPRITE) { GLint x, y; const GLfloat radius = 0.5F * size; const GLint z = (GLint) (vert->win[2]); GLuint count = 0; #if FLAGS & SMOOTH const GLfloat rmin = radius - 0.7071F; /* 0.7071 = sqrt(2)/2 */ const GLfloat rmax = radius + 0.7071F; const GLfloat rmin2 = MAX2(0.0F, rmin * rmin); const GLfloat rmax2 = rmax * rmax; const GLfloat cscale = 1.0F / (rmax2 - rmin2); const GLint xmin = (GLint) (vert->win[0] - radius); const GLint xmax = (GLint) (vert->win[0] + radius); const GLint ymin = (GLint) (vert->win[1] - radius); const GLint ymax = (GLint) (vert->win[1] + radius); #else /* non-smooth */ GLint xmin, xmax, ymin, ymax; GLint iSize = (GLint) (size + 0.5F); GLint iRadius; iSize = MAX2(1, iSize); iRadius = iSize / 2; if (iSize & 1) { /* odd size */ xmin = (GLint) (vert->win[0] - iRadius); xmax = (GLint) (vert->win[0] + iRadius); ymin = (GLint) (vert->win[1] - iRadius); ymax = (GLint) (vert->win[1] + iRadius); } else { /* even size */ xmin = (GLint) vert->win[0] - iRadius + 1; xmax = xmin + iSize - 1; ymin = (GLint) vert->win[1] - iRadius + 1; ymax = ymin + iSize - 1; } #endif /*SMOOTH*/ (void) radius; for (y = ymin; y <= ymax; y++) { for (x = xmin; x <= xmax; x++) { #if FLAGS & SPRITE GLuint 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; #if FLAGS & INDEX span->coverage[count] *= 15.0; /* coverage in [0,15] */ #endif } else { /* full coverage */ span->coverage[count] = 1.0F; } span->xArray[count] = x; span->yArray[count] = y; span->zArray[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; #endif /*ATTENUATE*/ #endif /*RGBA*/ count++; } /*if*/ #else /*SMOOTH*/ /* not smooth (square points) */ span->xArray[count] = x; span->yArray[count] = y; span->zArray[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; if (ctx->Point.SpriteRMode == GL_ZERO) span->texcoords[u][count][2] = 0.0F; else if (ctx->Point.SpriteRMode == GL_S) span->texcoords[u][count][2] = vert->texcoord[u][0]; else /* GL_R */ span->texcoords[u][count][2] = vert->texcoord[u][2]; } else { COPY_4V(span->texcoords[u][count], vert->texcoord[u]); } } } #endif /*SPRITE*/ count++; #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); #if FLAGS & (TEXTURE | SPRITE) if (ctx->Texture._ReallyEnabled) _mesa_write_texture_span(ctx, span); else _mesa_write_rgba_span(ctx, span); #elif FLAGS & RGBA _mesa_write_rgba_span(ctx, span); #else _mesa_write_index_span(ctx, span); #endif } #undef FLAGS #undef NAME