projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
*** empty log message ***
[mesa.git] / src / mesa / swrast / s_pointtemp.h
1 /*
2 * Mesa 3-D graphics library
3 * Version: 6.2
4 *
5 * Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 /*
26 * Regarding GL_NV_point_sprite:
27 *
28 * Portions of this software may use or implement intellectual
29 * property owned and licensed by NVIDIA Corporation. NVIDIA disclaims
30 * any and all warranties with respect to such intellectual property,
31 * including any use thereof or modifications thereto.
32 */
33
34
35 /*
36 * Point rendering template code.
37 *
38 * Set FLAGS = bitwise-OR of the following tokens:
39 *
40 * RGBA = do rgba instead of color index
41 * SMOOTH = do antialiasing
42 * TEXTURE = do texture coords
43 * SPECULAR = do separate specular color
44 * LARGE = do points with diameter > 1 pixel
45 * ATTENUATE = compute point size attenuation
46 * SPRITE = GL_ARB_point_sprite / GL_NV_point_sprite
47 *
48 * Notes: LARGE and ATTENUATE are exclusive of each other.
49 * TEXTURE requires RGBA
50 */
51
52
53 /*
54 * NOTES on antialiased point rasterization:
55 *
56 * Let d = distance of fragment center from vertex.
57 * if d < rmin2 then
58 * fragment has 100% coverage
59 * else if d > rmax2 then
60 * fragment has 0% coverage
61 * else
62 * fragment has % coverage = (d - rmin2) / (rmax2 - rmin2)
63 */
64
65
66
67 static void
68 NAME ( GLcontext *ctx, const SWvertex *vert )
69 {
70 #if FLAGS & (ATTENUATE | LARGE | SMOOTH | SPRITE)
71 GLfloat size;
72 #endif
73 #if FLAGS & RGBA
74 #if (FLAGS & ATTENUATE) && (FLAGS & SMOOTH)
75 GLfloat alphaAtten;
76 #endif
77 const GLchan red = vert->color[0];
78 const GLchan green = vert->color[1];
79 const GLchan blue = vert->color[2];
80 const GLchan alpha = vert->color[3];
81 #endif
82 #if FLAGS & SPECULAR
83 const GLchan specRed = vert->specular[0];
84 const GLchan specGreen = vert->specular[1];
85 const GLchan specBlue = vert->specular[2];
86 #endif
87 #if FLAGS & INDEX
88 const GLuint colorIndex = (GLuint) vert->index; /* XXX round? */
89 #endif
90 #if FLAGS & TEXTURE
91 GLfloat texcoord[MAX_TEXTURE_COORD_UNITS][4];
92 GLuint u;
93 #endif
94 SWcontext *swrast = SWRAST_CONTEXT(ctx);
95 struct sw_span *span = &(swrast->PointSpan);
96
97 /* Cull primitives with malformed coordinates.
98 */
99 {
100 float tmp = vert->win[0] + vert->win[1];
101 if (IS_INF_OR_NAN(tmp))
102 return;
103 }
104
105 /*
106 * Span init
107 */
108 span->interpMask = SPAN_FOG;
109 span->arrayMask = SPAN_XY | SPAN_Z;
110 span->fog = vert->fog;
111 span->fogStep = 0.0;
112 #if FLAGS & RGBA
113 span->arrayMask |= SPAN_RGBA;
114 #endif
115 #if FLAGS & SPECULAR
116 span->arrayMask |= SPAN_SPEC;
117 #endif
118 #if FLAGS & INDEX
119 span->arrayMask |= SPAN_INDEX;
120 #endif
121 #if FLAGS & TEXTURE
122 span->arrayMask |= SPAN_TEXTURE;
123 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
124 if (ctx->Texture.Unit[u]._ReallyEnabled) {
125 const GLfloat q = vert->texcoord[u][3];
126 const GLfloat invQ = (q == 0.0F || q == 1.0F) ? 1.0F : (1.0F / q);
127 texcoord[u][0] = vert->texcoord[u][0] * invQ;
128 texcoord[u][1] = vert->texcoord[u][1] * invQ;
129 texcoord[u][2] = vert->texcoord[u][2] * invQ;
130 texcoord[u][3] = q;
131 }
132 }
133 #endif
134 #if FLAGS & SMOOTH
135 span->arrayMask |= SPAN_COVERAGE;
136 #endif
137 #if FLAGS & SPRITE
138 span->arrayMask |= SPAN_TEXTURE;
139 #endif
140
141 #if FLAGS & ATTENUATE
142 if (vert->pointSize >= ctx->Point.Threshold) {
143 size = MIN2(vert->pointSize, ctx->Point.MaxSize);
144 #if (FLAGS & RGBA) && (FLAGS & SMOOTH)
145 alphaAtten = 1.0F;
146 #endif
147 }
148 else {
149 #if (FLAGS & RGBA) && (FLAGS & SMOOTH)
150 GLfloat dsize = vert->pointSize / ctx->Point.Threshold;
151 alphaAtten = dsize * dsize;
152 #endif
153 size = MAX2(ctx->Point.Threshold, ctx->Point.MinSize);
154 }
155 #elif FLAGS & (LARGE | SMOOTH | SPRITE)
156 size = ctx->Point._Size;
157 #endif
158
159 #if FLAGS & (ATTENUATE | LARGE | SMOOTH | SPRITE)
160 /*
161 * Multi-pixel points
162 */
163 {{
164 GLint x, y;
165 const GLfloat radius = 0.5F * size;
166 const GLint z = (GLint) (vert->win[2] + 0.5F);
167 GLuint count;
168 #if FLAGS & SMOOTH
169 const GLfloat rmin = radius - 0.7071F; /* 0.7071 = sqrt(2)/2 */
170 const GLfloat rmax = radius + 0.7071F;
171 const GLfloat rmin2 = MAX2(0.0F, rmin * rmin);
172 const GLfloat rmax2 = rmax * rmax;
173 const GLfloat cscale = 1.0F / (rmax2 - rmin2);
174 const GLint xmin = (GLint) (vert->win[0] - radius);
175 const GLint xmax = (GLint) (vert->win[0] + radius);
176 const GLint ymin = (GLint) (vert->win[1] - radius);
177 const GLint ymax = (GLint) (vert->win[1] + radius);
178 #else
179 /* non-smooth */
180 GLint xmin, xmax, ymin, ymax;
181 GLint iSize = (GLint) (size + 0.5F);
182 GLint iRadius;
183 iSize = MAX2(1, iSize);
184 iRadius = iSize / 2;
185 if (iSize & 1) {
186 /* odd size */
187 xmin = (GLint) (vert->win[0] - iRadius);
188 xmax = (GLint) (vert->win[0] + iRadius);
189 ymin = (GLint) (vert->win[1] - iRadius);
190 ymax = (GLint) (vert->win[1] + iRadius);
191 }
192 else {
193 /* even size */
194 xmin = (GLint) vert->win[0] - iRadius + 1;
195 xmax = xmin + iSize - 1;
196 ymin = (GLint) vert->win[1] - iRadius + 1;
197 ymax = ymin + iSize - 1;
198 }
199 #endif /*SMOOTH*/
200
201 /* check if we need to flush */
202 if (span->end + (xmax-xmin+1) * (ymax-ymin+1) >= MAX_WIDTH ||
203 (swrast->_RasterMask & (BLEND_BIT | LOGIC_OP_BIT | MASKING_BIT))) {
204 #if FLAGS & (TEXTURE | SPRITE)
205 if (ctx->Texture._EnabledUnits)
206 _swrast_write_texture_span(ctx, span);
207 else
208 _swrast_write_rgba_span(ctx, span);
209 #elif FLAGS & RGBA
210 _swrast_write_rgba_span(ctx, span);
211 #else
212 _swrast_write_index_span(ctx, span);
213 #endif
214 span->end = 0;
215 }
216
217 /*
218 * OK, generate fragments
219 */
220 count = span->end;
221 (void) radius;
222 for (y = ymin; y <= ymax; y++) {
223 /* check if we need to flush */
224 if (count + (xmax-xmin+1) >= MAX_WIDTH) {
225 span->end = count;
226 #if FLAGS & (TEXTURE | SPRITE)
227 if (ctx->Texture._EnabledUnits)
228 _swrast_write_texture_span(ctx, span);
229 else
230 _swrast_write_rgba_span(ctx, span);
231 #elif FLAGS & RGBA
232 _swrast_write_rgba_span(ctx, span);
233 #else
234 _swrast_write_index_span(ctx, span);
235 #endif
236 count = span->end = 0;
237 }
238 for (x = xmin; x <= xmax; x++) {
239 #if FLAGS & (SPRITE | TEXTURE)
240 GLuint u;
241 #endif
242
243 #if FLAGS & RGBA
244 span->array->rgba[count][RCOMP] = red;
245 span->array->rgba[count][GCOMP] = green;
246 span->array->rgba[count][BCOMP] = blue;
247 span->array->rgba[count][ACOMP] = alpha;
248 #endif
249 #if FLAGS & SPECULAR
250 span->array->spec[count][RCOMP] = specRed;
251 span->array->spec[count][GCOMP] = specGreen;
252 span->array->spec[count][BCOMP] = specBlue;
253 #endif
254 #if FLAGS & INDEX
255 span->array->index[count] = colorIndex;
256 #endif
257 #if FLAGS & TEXTURE
258 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
259 if (ctx->Texture.Unit[u]._ReallyEnabled) {
260 COPY_4V(span->array->texcoords[u][count], texcoord[u]);
261 }
262 }
263 #endif
264
265 #if FLAGS & SMOOTH
266 /* compute coverage */
267 {
268 const GLfloat dx = x - vert->win[0] + 0.5F;
269 const GLfloat dy = y - vert->win[1] + 0.5F;
270 const GLfloat dist2 = dx * dx + dy * dy;
271 if (dist2 < rmax2) {
272 if (dist2 >= rmin2) {
273 /* compute partial coverage */
274 span->array->coverage[count] = 1.0F - (dist2 - rmin2) * cscale;
275 #if FLAGS & INDEX
276 /* coverage in [0,15] */
277 span->array->coverage[count] *= 15.0;
278 #endif
279 }
280 else {
281 /* full coverage */
282 span->array->coverage[count] = 1.0F;
283 }
284
285 span->array->x[count] = x;
286 span->array->y[count] = y;
287 span->array->z[count] = z;
288
289 #if (FLAGS & ATTENUATE) && (FLAGS & RGBA)
290 span->array->rgba[count][ACOMP] = (GLchan) (alpha * alphaAtten);
291 #elif FLAGS & RGBA
292 span->array->rgba[count][ACOMP] = alpha;
293 #endif /*ATTENUATE*/
294 count++;
295 } /*if*/
296 }
297
298 #else /*SMOOTH*/
299
300 /* not smooth (square points) */
301 span->array->x[count] = x;
302 span->array->y[count] = y;
303 span->array->z[count] = z;
304
305 #if FLAGS & SPRITE
306 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
307 if (ctx->Texture.Unit[u]._ReallyEnabled) {
308 if (ctx->Point.CoordReplace[u]) {
309 GLfloat s = 0.5F + (x + 0.5F - vert->win[0]) / size;
310 GLfloat t;
311 if (ctx->Point.SpriteOrigin == GL_LOWER_LEFT)
312 t = 0.5F + (y + 0.5F - vert->win[1]) / size;
313 else /* GL_UPPER_LEFT */
314 t = 0.5F - (y + 0.5F - vert->win[1]) / size;
315 span->array->texcoords[u][count][0] = s;
316 span->array->texcoords[u][count][1] = t;
317 span->array->texcoords[u][count][3] = 1.0F;
318 if (ctx->Point.SpriteRMode == GL_ZERO)
319 span->array->texcoords[u][count][2] = 0.0F;
320 else if (ctx->Point.SpriteRMode == GL_S)
321 span->array->texcoords[u][count][2] = vert->texcoord[u][0];
322 else /* GL_R */
323 span->array->texcoords[u][count][2] = vert->texcoord[u][2];
324 }
325 else {
326 COPY_4V(span->array->texcoords[u][count], vert->texcoord[u]);
327 }
328 }
329 }
330 #endif /*SPRITE*/
331
332 count++; /* square point */
333
334 #endif /*SMOOTH*/
335
336 } /*for x*/
337 } /*for y*/
338 span->end = count;
339 }}
340
341 #else /* LARGE | ATTENUATE | SMOOTH | SPRITE */
342
343 /*
344 * Single-pixel points
345 */
346 {{
347 GLuint count;
348
349 /* check if we need to flush */
350 if (span->end >= MAX_WIDTH ||
351 (swrast->_RasterMask & (BLEND_BIT | LOGIC_OP_BIT | MASKING_BIT))) {
352 #if FLAGS & (TEXTURE | SPRITE)
353 if (ctx->Texture._EnabledUnits)
354 _swrast_write_texture_span(ctx, span);
355 else
356 _swrast_write_rgba_span(ctx, span);
357 #elif FLAGS & RGBA
358 _swrast_write_rgba_span(ctx, span);
359 #else
360 _swrast_write_index_span(ctx, span);
361 #endif
362 span->end = 0;
363 }
364
365 count = span->end;
366
367 #if FLAGS & RGBA
368 span->array->rgba[count][RCOMP] = red;
369 span->array->rgba[count][GCOMP] = green;
370 span->array->rgba[count][BCOMP] = blue;
371 span->array->rgba[count][ACOMP] = alpha;
372 #endif
373 #if FLAGS & SPECULAR
374 span->array->spec[count][RCOMP] = specRed;
375 span->array->spec[count][GCOMP] = specGreen;
376 span->array->spec[count][BCOMP] = specBlue;
377 #endif
378 #if FLAGS & INDEX
379 span->array->index[count] = colorIndex;
380 #endif
381 #if FLAGS & TEXTURE
382 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
383 if (ctx->Texture.Unit[u]._ReallyEnabled) {
384 COPY_4V(span->array->texcoords[u][count], texcoord[u]);
385 }
386 }
387 #endif
388
389 span->array->x[count] = (GLint) vert->win[0];
390 span->array->y[count] = (GLint) vert->win[1];
391 span->array->z[count] = (GLint) (vert->win[2] + 0.5F);
392 span->end = count + 1;
393 }}
394
395 #endif /* LARGE || ATTENUATE || SMOOTH */
396
397 ASSERT(span->end <= MAX_WIDTH);
398 }
399
400
401 #undef FLAGS
402 #undef NAME