1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26 /*
27 * Line Rasterizer Template
28 *
29 * This file is #include'd to generate custom line rasterizers.
30 *
31 * The following macros may be defined to indicate what auxillary information
32 * must be interplated along the line:
33 * INTERP_Z - if defined, interpolate Z values
34 * INTERP_ATTRIBS - if defined, interpolate attribs (texcoords, varying, etc)
35 *
36 * When one can directly address pixels in the color buffer the following
37 * macros can be defined and used to directly compute pixel addresses during
38 * rasterization (see pixelPtr):
39 * PIXEL_TYPE - the datatype of a pixel (GLubyte, GLushort, GLuint)
40 * BYTES_PER_ROW - number of bytes per row in the color buffer
41 * PIXEL_ADDRESS(X,Y) - returns the address of pixel at (X,Y) where
42 * Y==0 at bottom of screen and increases upward.
43 *
44 * Similarly, for direct depth buffer access, this type is used for depth
45 * buffer addressing:
46 * DEPTH_TYPE - either GLushort or GLuint
47 *
48 * Optionally, one may provide one-time setup code
49 * SETUP_CODE - code which is to be executed once per line
50 *
51 * To actually "plot" each pixel the PLOT macro must be defined...
52 * PLOT(X,Y) - code to plot a pixel. Example:
53 * if (Z < *zPtr) {
54 * *zPtr = Z;
55 * color = pack_rgb( FixedToInt(r0), FixedToInt(g0),
56 * FixedToInt(b0) );
57 * put_pixel( X, Y, color );
58 * }
59 *
60 * This code was designed for the origin to be in the lower-left corner.
61 *
62 */
63
64
65 static void
NAME(struct gl_context * ctx,const SWvertex * vert0,const SWvertex * vert1)66 NAME( struct gl_context *ctx, const SWvertex *vert0, const SWvertex *vert1 )
67 {
68 const SWcontext *swrast = SWRAST_CONTEXT(ctx);
69 SWspan span;
70 GLuint interpFlags = 0;
71 GLint x0 = (GLint) vert0->attrib[VARYING_SLOT_POS][0];
72 GLint x1 = (GLint) vert1->attrib[VARYING_SLOT_POS][0];
73 GLint y0 = (GLint) vert0->attrib[VARYING_SLOT_POS][1];
74 GLint y1 = (GLint) vert1->attrib[VARYING_SLOT_POS][1];
75 GLint dx, dy;
76 GLint numPixels;
77 GLint xstep, ystep;
78 #if defined(DEPTH_TYPE)
79 const GLint depthBits = ctx->DrawBuffer->Visual.depthBits;
80 const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
81 struct gl_renderbuffer *zrb = ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
82 #define FixedToDepth(F) ((F) >> fixedToDepthShift)
83 GLint zPtrXstep, zPtrYstep;
84 DEPTH_TYPE *zPtr;
85 #elif defined(INTERP_Z)
86 const GLint depthBits = ctx->DrawBuffer->Visual.depthBits;
87 #endif
88 #ifdef PIXEL_ADDRESS
89 PIXEL_TYPE *pixelPtr;
90 GLint pixelXstep, pixelYstep;
91 #endif
92
93 #ifdef SETUP_CODE
94 SETUP_CODE
95 #endif
96
97 (void) swrast;
98
99 /* Cull primitives with malformed coordinates.
100 */
101 {
102 GLfloat tmp = vert0->attrib[VARYING_SLOT_POS][0] + vert0->attrib[VARYING_SLOT_POS][1]
103 + vert1->attrib[VARYING_SLOT_POS][0] + vert1->attrib[VARYING_SLOT_POS][1];
104 if (IS_INF_OR_NAN(tmp))
105 return;
106 }
107
108 /*
109 printf("%s():\n", __func__);
110 printf(" (%f, %f, %f) -> (%f, %f, %f)\n",
111 vert0->attrib[VARYING_SLOT_POS][0],
112 vert0->attrib[VARYING_SLOT_POS][1],
113 vert0->attrib[VARYING_SLOT_POS][2],
114 vert1->attrib[VARYING_SLOT_POS][0],
115 vert1->attrib[VARYING_SLOT_POS][1],
116 vert1->attrib[VARYING_SLOT_POS][2]);
117 printf(" (%d, %d, %d) -> (%d, %d, %d)\n",
118 vert0->color[0], vert0->color[1], vert0->color[2],
119 vert1->color[0], vert1->color[1], vert1->color[2]);
120 printf(" (%d, %d, %d) -> (%d, %d, %d)\n",
121 vert0->specular[0], vert0->specular[1], vert0->specular[2],
122 vert1->specular[0], vert1->specular[1], vert1->specular[2]);
123 */
124
125 /*
126 * Despite being clipped to the view volume, the line's window coordinates
127 * may just lie outside the window bounds. That is, if the legal window
128 * coordinates are [0,W-1][0,H-1], it's possible for x==W and/or y==H.
129 * This quick and dirty code nudges the endpoints inside the window if
130 * necessary.
131 */
132 #ifdef CLIP_HACK
133 {
134 GLint w = ctx->DrawBuffer->Width;
135 GLint h = ctx->DrawBuffer->Height;
136 if ((x0==w) | (x1==w)) {
137 if ((x0==w) & (x1==w))
138 return;
139 x0 -= x0==w;
140 x1 -= x1==w;
141 }
142 if ((y0==h) | (y1==h)) {
143 if ((y0==h) & (y1==h))
144 return;
145 y0 -= y0==h;
146 y1 -= y1==h;
147 }
148 }
149 #endif
150
151 dx = x1 - x0;
152 dy = y1 - y0;
153 if (dx == 0 && dy == 0)
154 return;
155
156 /*
157 printf("%s %d,%d %g %g %g %g %g %g %g %g\n", __func__, dx, dy,
158 vert0->attrib[VARYING_SLOT_COL1][0],
159 vert0->attrib[VARYING_SLOT_COL1][1],
160 vert0->attrib[VARYING_SLOT_COL1][2],
161 vert0->attrib[VARYING_SLOT_COL1][3],
162 vert1->attrib[VARYING_SLOT_COL1][0],
163 vert1->attrib[VARYING_SLOT_COL1][1],
164 vert1->attrib[VARYING_SLOT_COL1][2],
165 vert1->attrib[VARYING_SLOT_COL1][3]);
166 */
167
168 #ifdef DEPTH_TYPE
169 zPtr = (DEPTH_TYPE *) _swrast_pixel_address(zrb, x0, y0);
170 #endif
171 #ifdef PIXEL_ADDRESS
172 pixelPtr = (PIXEL_TYPE *) PIXEL_ADDRESS(x0,y0);
173 #endif
174
175 if (dx<0) {
176 dx = -dx; /* make positive */
177 xstep = -1;
178 #ifdef DEPTH_TYPE
179 zPtrXstep = -((GLint)sizeof(DEPTH_TYPE));
180 #endif
181 #ifdef PIXEL_ADDRESS
182 pixelXstep = -((GLint)sizeof(PIXEL_TYPE));
183 #endif
184 }
185 else {
186 xstep = 1;
187 #ifdef DEPTH_TYPE
188 zPtrXstep = ((GLint)sizeof(DEPTH_TYPE));
189 #endif
190 #ifdef PIXEL_ADDRESS
191 pixelXstep = ((GLint)sizeof(PIXEL_TYPE));
192 #endif
193 }
194
195 if (dy<0) {
196 dy = -dy; /* make positive */
197 ystep = -1;
198 #ifdef DEPTH_TYPE
199 zPtrYstep = -((GLint) (ctx->DrawBuffer->Width * sizeof(DEPTH_TYPE)));
200 #endif
201 #ifdef PIXEL_ADDRESS
202 pixelYstep = BYTES_PER_ROW;
203 #endif
204 }
205 else {
206 ystep = 1;
207 #ifdef DEPTH_TYPE
208 zPtrYstep = (GLint) (ctx->DrawBuffer->Width * sizeof(DEPTH_TYPE));
209 #endif
210 #ifdef PIXEL_ADDRESS
211 pixelYstep = -(BYTES_PER_ROW);
212 #endif
213 }
214
215 assert(dx >= 0);
216 assert(dy >= 0);
217
218 numPixels = MAX2(dx, dy);
219
220 /*
221 * Span setup: compute start and step values for all interpolated values.
222 */
223 interpFlags |= SPAN_RGBA;
224 if (ctx->Light.ShadeModel == GL_SMOOTH) {
225 span.red = ChanToFixed(vert0->color[0]);
226 span.green = ChanToFixed(vert0->color[1]);
227 span.blue = ChanToFixed(vert0->color[2]);
228 span.alpha = ChanToFixed(vert0->color[3]);
229 span.redStep = (ChanToFixed(vert1->color[0]) - span.red ) / numPixels;
230 span.greenStep = (ChanToFixed(vert1->color[1]) - span.green) / numPixels;
231 span.blueStep = (ChanToFixed(vert1->color[2]) - span.blue ) / numPixels;
232 span.alphaStep = (ChanToFixed(vert1->color[3]) - span.alpha) / numPixels;
233 }
234 else {
235 span.red = ChanToFixed(vert1->color[0]);
236 span.green = ChanToFixed(vert1->color[1]);
237 span.blue = ChanToFixed(vert1->color[2]);
238 span.alpha = ChanToFixed(vert1->color[3]);
239 span.redStep = 0;
240 span.greenStep = 0;
241 span.blueStep = 0;
242 span.alphaStep = 0;
243 }
244 #if defined(INTERP_Z) || defined(DEPTH_TYPE)
245 interpFlags |= SPAN_Z;
246 {
247 if (depthBits <= 16) {
248 span.z = FloatToFixed(vert0->attrib[VARYING_SLOT_POS][2]) + FIXED_HALF;
249 span.zStep = FloatToFixed( vert1->attrib[VARYING_SLOT_POS][2]
250 - vert0->attrib[VARYING_SLOT_POS][2]) / numPixels;
251 }
252 else {
253 /* don't use fixed point */
254 span.z = (GLuint) vert0->attrib[VARYING_SLOT_POS][2];
255 span.zStep = (GLint) (( vert1->attrib[VARYING_SLOT_POS][2]
256 - vert0->attrib[VARYING_SLOT_POS][2]) / numPixels);
257 }
258 }
259 #endif
260 #if defined(INTERP_ATTRIBS)
261 {
262 const GLfloat invLen = 1.0F / numPixels;
263 const GLfloat invw0 = vert0->attrib[VARYING_SLOT_POS][3];
264 const GLfloat invw1 = vert1->attrib[VARYING_SLOT_POS][3];
265
266 span.attrStart[VARYING_SLOT_POS][3] = invw0;
267 span.attrStepX[VARYING_SLOT_POS][3] = (invw1 - invw0) * invLen;
268 span.attrStepY[VARYING_SLOT_POS][3] = 0.0;
269
270 ATTRIB_LOOP_BEGIN
271 if (swrast->_InterpMode[attr] == GL_FLAT) {
272 COPY_4V(span.attrStart[attr], vert1->attrib[attr]);
273 ASSIGN_4V(span.attrStepX[attr], 0.0, 0.0, 0.0, 0.0);
274 }
275 else {
276 GLuint c;
277 for (c = 0; c < 4; c++) {
278 float da;
279 span.attrStart[attr][c] = invw0 * vert0->attrib[attr][c];
280 da = (invw1 * vert1->attrib[attr][c]) - span.attrStart[attr][c];
281 span.attrStepX[attr][c] = da * invLen;
282 }
283 }
284 ASSIGN_4V(span.attrStepY[attr], 0.0, 0.0, 0.0, 0.0);
285 ATTRIB_LOOP_END
286 }
287 #endif
288
289 INIT_SPAN(span, GL_LINE);
290 span.end = numPixels;
291 span.interpMask = interpFlags;
292 span.arrayMask = SPAN_XY;
293
294 span.facing = swrast->PointLineFacing;
295
296
297 /*
298 * Draw
299 */
300
301 if (dx > dy) {
302 /*** X-major line ***/
303 GLint i;
304 GLint errorInc = dy+dy;
305 GLint error = errorInc-dx;
306 GLint errorDec = error-dx;
307
308 for (i = 0; i < dx; i++) {
309 #ifdef DEPTH_TYPE
310 GLuint Z = FixedToDepth(span.z);
311 #endif
312 #ifdef PLOT
313 PLOT( x0, y0 );
314 #else
315 span.array->x[i] = x0;
316 span.array->y[i] = y0;
317 #endif
318 x0 += xstep;
319 #ifdef DEPTH_TYPE
320 zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);
321 span.z += span.zStep;
322 #endif
323 #ifdef PIXEL_ADDRESS
324 pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);
325 #endif
326 if (error < 0) {
327 error += errorInc;
328 }
329 else {
330 error += errorDec;
331 y0 += ystep;
332 #ifdef DEPTH_TYPE
333 zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);
334 #endif
335 #ifdef PIXEL_ADDRESS
336 pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);
337 #endif
338 }
339 }
340 }
341 else {
342 /*** Y-major line ***/
343 GLint i;
344 GLint errorInc = dx+dx;
345 GLint error = errorInc-dy;
346 GLint errorDec = error-dy;
347
348 for (i=0;i<dy;i++) {
349 #ifdef DEPTH_TYPE
350 GLuint Z = FixedToDepth(span.z);
351 #endif
352 #ifdef PLOT
353 PLOT( x0, y0 );
354 #else
355 span.array->x[i] = x0;
356 span.array->y[i] = y0;
357 #endif
358 y0 += ystep;
359 #ifdef DEPTH_TYPE
360 zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);
361 span.z += span.zStep;
362 #endif
363 #ifdef PIXEL_ADDRESS
364 pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);
365 #endif
366 if (error<0) {
367 error += errorInc;
368 }
369 else {
370 error += errorDec;
371 x0 += xstep;
372 #ifdef DEPTH_TYPE
373 zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);
374 #endif
375 #ifdef PIXEL_ADDRESS
376 pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);
377 #endif
378 }
379 }
380 }
381
382 #ifdef RENDER_SPAN
383 RENDER_SPAN( span );
384 #endif
385
386 (void)span;
387
388 }
389
390
391 #undef NAME
392 #undef INTERP_Z
393 #undef INTERP_ATTRIBS
394 #undef PIXEL_ADDRESS
395 #undef PIXEL_TYPE
396 #undef DEPTH_TYPE
397 #undef BYTES_PER_ROW
398 #undef SETUP_CODE
399 #undef PLOT
400 #undef CLIP_HACK
401 #undef FixedToDepth
402 #undef RENDER_SPAN
403