projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
define Bool for solo builds
[mesa.git] / src / mesa / swrast / s_pointtemp.h
1 /*
2 * Mesa 3-D graphics library
3 * Version: 6.3
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 if (ctx->FragmentProgram._Active) {
124 /* Don't divide texture s,t,r by q (use TXP to do that) */
125 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
126 if (ctx->Texture._EnabledCoordUnits & (1 << u)) {
127 COPY_4V(texcoord[u], vert->texcoord[u]);
128 }
129 }
130 }
131 else {
132 /* Divide texture s,t,r by q here */
133 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
134 if (ctx->Texture._EnabledCoordUnits & (1 << u)) {
135 const GLfloat q = vert->texcoord[u][3];
136 const GLfloat invQ = (q == 0.0F || q == 1.0F) ? 1.0F : (1.0F / q);
137 texcoord[u][0] = vert->texcoord[u][0] * invQ;
138 texcoord[u][1] = vert->texcoord[u][1] * invQ;
139 texcoord[u][2] = vert->texcoord[u][2] * invQ;
140 texcoord[u][3] = q;
141 }
142 }
143 }
144 /* need these for fragment programs */
145 span->w = 1.0F;
146 span->dwdx = 0.0F;
147 span->dwdy = 0.0F;
148 #endif
149 #if FLAGS & SMOOTH
150 span->arrayMask |= SPAN_COVERAGE;
151 #endif
152 #if FLAGS & SPRITE
153 span->arrayMask |= SPAN_TEXTURE;
154 #endif
155
156 #if FLAGS & ATTENUATE
157 if (vert->pointSize >= ctx->Point.Threshold) {
158 size = MIN2(vert->pointSize, ctx->Point.MaxSize);
159 #if (FLAGS & RGBA) && (FLAGS & SMOOTH)
160 alphaAtten = 1.0F;
161 #endif
162 }
163 else {
164 #if (FLAGS & RGBA) && (FLAGS & SMOOTH)
165 GLfloat dsize = vert->pointSize / ctx->Point.Threshold;
166 alphaAtten = dsize * dsize;
167 #endif
168 size = MAX2(ctx->Point.Threshold, ctx->Point.MinSize);
169 }
170 #elif FLAGS & (LARGE | SMOOTH | SPRITE)
171 size = ctx->Point._Size;
172 #endif
173
174 #if FLAGS & (ATTENUATE | LARGE | SMOOTH | SPRITE)
175 /*
176 * Multi-pixel points
177 */
178 {{
179 GLint x, y;
180 const GLfloat radius = 0.5F * size;
181 const GLint z = (GLint) (vert->win[2] + 0.5F);
182 GLuint count;
183 #if FLAGS & SMOOTH
184 const GLfloat rmin = radius - 0.7071F; /* 0.7071 = sqrt(2)/2 */
185 const GLfloat rmax = radius + 0.7071F;
186 const GLfloat rmin2 = MAX2(0.0F, rmin * rmin);
187 const GLfloat rmax2 = rmax * rmax;
188 const GLfloat cscale = 1.0F / (rmax2 - rmin2);
189 const GLint xmin = (GLint) (vert->win[0] - radius);
190 const GLint xmax = (GLint) (vert->win[0] + radius);
191 const GLint ymin = (GLint) (vert->win[1] - radius);
192 const GLint ymax = (GLint) (vert->win[1] + radius);
193 #else
194 /* non-smooth */
195 GLint xmin, xmax, ymin, ymax;
196 GLint iSize = (GLint) (size + 0.5F);
197 GLint iRadius;
198 iSize = MAX2(1, iSize);
199 iRadius = iSize / 2;
200 if (iSize & 1) {
201 /* odd size */
202 xmin = (GLint) (vert->win[0] - iRadius);
203 xmax = (GLint) (vert->win[0] + iRadius);
204 ymin = (GLint) (vert->win[1] - iRadius);
205 ymax = (GLint) (vert->win[1] + iRadius);
206 }
207 else {
208 /* even size */
209 xmin = (GLint) vert->win[0] - iRadius + 1;
210 xmax = xmin + iSize - 1;
211 ymin = (GLint) vert->win[1] - iRadius + 1;
212 ymax = ymin + iSize - 1;
213 }
214 #endif /*SMOOTH*/
215
216 /* check if we need to flush */
217 if (span->end + (xmax-xmin+1) * (ymax-ymin+1) >= MAX_WIDTH ||
218 (swrast->_RasterMask & (BLEND_BIT | LOGIC_OP_BIT | MASKING_BIT))) {
219 #if FLAGS & RGBA
220 _swrast_write_rgba_span(ctx, span);
221 #else
222 _swrast_write_index_span(ctx, span);
223 #endif
224 span->end = 0;
225 }
226
227 /*
228 * OK, generate fragments
229 */
230 count = span->end;
231 (void) radius;
232 for (y = ymin; y <= ymax; y++) {
233 /* check if we need to flush */
234 if (count + (xmax-xmin+1) >= MAX_WIDTH) {
235 span->end = count;
236 #if FLAGS & RGBA
237 _swrast_write_rgba_span(ctx, span);
238 #else
239 _swrast_write_index_span(ctx, span);
240 #endif
241 count = span->end = 0;
242 }
243 for (x = xmin; x <= xmax; x++) {
244 #if FLAGS & (SPRITE | TEXTURE)
245 GLuint u;
246 #endif
247
248 #if FLAGS & RGBA
249 span->array->rgba[count][RCOMP] = red;
250 span->array->rgba[count][GCOMP] = green;
251 span->array->rgba[count][BCOMP] = blue;
252 span->array->rgba[count][ACOMP] = alpha;
253 #endif
254 #if FLAGS & SPECULAR
255 span->array->spec[count][RCOMP] = specRed;
256 span->array->spec[count][GCOMP] = specGreen;
257 span->array->spec[count][BCOMP] = specBlue;
258 #endif
259 #if FLAGS & INDEX
260 span->array->index[count] = colorIndex;
261 #endif
262 #if FLAGS & TEXTURE
263 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
264 if (ctx->Texture._EnabledCoordUnits & (1 << u)) {
265 COPY_4V(span->array->texcoords[u][count], texcoord[u]);
266 }
267 }
268 #endif
269
270 #if FLAGS & SMOOTH
271 /* compute coverage */
272 {
273 const GLfloat dx = x - vert->win[0] + 0.5F;
274 const GLfloat dy = y - vert->win[1] + 0.5F;
275 const GLfloat dist2 = dx * dx + dy * dy;
276 if (dist2 < rmax2) {
277 if (dist2 >= rmin2) {
278 /* compute partial coverage */
279 span->array->coverage[count] = 1.0F - (dist2 - rmin2) * cscale;
280 #if FLAGS & INDEX
281 /* coverage in [0,15] */
282 span->array->coverage[count] *= 15.0;
283 #endif
284 }
285 else {
286 /* full coverage */
287 span->array->coverage[count] = 1.0F;
288 }
289
290 span->array->x[count] = x;
291 span->array->y[count] = y;
292 span->array->z[count] = z;
293
294 #if (FLAGS & ATTENUATE) && (FLAGS & RGBA)
295 span->array->rgba[count][ACOMP] = (GLchan) (alpha * alphaAtten);
296 #elif FLAGS & RGBA
297 span->array->rgba[count][ACOMP] = alpha;
298 #endif /*ATTENUATE*/
299 count++;
300 } /*if*/
301 }
302
303 #else /*SMOOTH*/
304
305 /* not smooth (square points) */
306 span->array->x[count] = x;
307 span->array->y[count] = y;
308 span->array->z[count] = z;
309
310 #if FLAGS & SPRITE
311 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
312 if (ctx->Texture.Unit[u]._ReallyEnabled) {
313 if (ctx->Point.CoordReplace[u]) {
314 GLfloat s = 0.5F + (x + 0.5F - vert->win[0]) / size;
315 GLfloat t;
316 if (ctx->Point.SpriteOrigin == GL_LOWER_LEFT)
317 t = 0.5F + (y + 0.5F - vert->win[1]) / size;
318 else /* GL_UPPER_LEFT */
319 t = 0.5F - (y + 0.5F - vert->win[1]) / size;
320 span->array->texcoords[u][count][0] = s;
321 span->array->texcoords[u][count][1] = t;
322 span->array->texcoords[u][count][3] = 1.0F;
323 if (ctx->Point.SpriteRMode == GL_ZERO)
324 span->array->texcoords[u][count][2] = 0.0F;
325 else if (ctx->Point.SpriteRMode == GL_S)
326 span->array->texcoords[u][count][2] = vert->texcoord[u][0];
327 else /* GL_R */
328 span->array->texcoords[u][count][2] = vert->texcoord[u][2];
329 }
330 else {
331 COPY_4V(span->array->texcoords[u][count], vert->texcoord[u]);
332 }
333 }
334 }
335 #endif /*SPRITE*/
336
337 count++; /* square point */
338
339 #endif /*SMOOTH*/
340
341 } /*for x*/
342 } /*for y*/
343 span->end = count;
344 }}
345
346 #else /* LARGE | ATTENUATE | SMOOTH | SPRITE */
347
348 /*
349 * Single-pixel points
350 */
351 {{
352 GLuint count;
353
354 /* check if we need to flush */
355 if (span->end >= MAX_WIDTH ||
356 (swrast->_RasterMask & (BLEND_BIT | LOGIC_OP_BIT | MASKING_BIT))) {
357 #if 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