Doxygen fix.
[bertos.git] / gfx / line.c
1 /*!
2  * \file
3  * <!--
4  * Copyright 2003, 2004, 2005 Develer S.r.l. (http://www.develer.com/)
5  * Copyright 1999 Bernardo Innocenti <bernie@develer.com>
6  * This file is part of DevLib - See README.devlib for information.
7  * -->
8  *
9  * \version $Id$
10  *
11  * \author Bernardo Innocenti <bernie@develer.com>
12  * \author Stefano Fedrigo <aleph@develer.com>
13  *
14  * \brief Line drawing graphics routines
15  */
16
17 /*#*
18  *#* $Log$
19  *#* Revision 1.2  2006/02/10 12:26:58  bernie
20  *#* Check CONFIG_* constraints.
21  *#*
22  *#* Revision 1.1  2006/01/24 02:17:49  bernie
23  *#* Split out gfx.c into bitmap.c and line.c.
24  *#*
25  *#*/
26
27 #include "gfx.h"
28 #include "gfx_p.h"
29
30 #include <cfg/debug.h>   /* ASSERT() */
31 #include <cfg/cpu.h>     /* CPU_HARVARD */
32 #include <cfg/macros.h>  /* SWAP() */
33 #include <appconfig.h>   /* CONFIG_GFX_CLIPPING */
34
35 /* Configuration sanity checks */
36 #if !defined(CONFIG_GFX_CLIPPING) || (CONFIG_GFX_CLIPPING != 0 && CONFIG_GFX_CLIPPING != 1)
37         #error CONFIG_GFX_CLIPPING must be defined to either 0 or 1
38 #endif
39 #if !defined(CONFIG_GFX_VCOORDS) || (CONFIG_GFX_VCOORDS != 0 && CONFIG_GFX_VCOORDS != 1)
40         #error CONFIG_GFX_VCOORDS must be defined to either 0 or 1
41 #endif
42
43 /*!
44  * Draw a sloped line without performing clipping.
45  *
46  * Parameters are the same of gfx_line().
47  * This routine is based on the Bresenham Line-Drawing Algorithm.
48  *
49  * \note Passing coordinates outside the bitmap boundaries will
50  *       result in memory trashing.
51  *
52  * \todo Optimize for vertical and horiziontal lines.
53  *
54  * \sa gfx_line()
55  */
56 static void gfx_lineUnclipped(Bitmap *bm, coord_t x1, coord_t y1, coord_t x2, coord_t y2)
57 {
58         int x, y, e, len, adx, ady, signx, signy;
59
60         if (x2 > x1)
61         {
62                 /* left to right */
63                 signx = +1;
64                 adx = x2 - x1;
65         }
66         else
67         {
68                 /* right to left */
69                 signx = -1;
70                 adx = x1 - x2;
71         }
72
73         if (y2 > y1)
74         {
75                 /* top to bottom */
76                 signy = +1;
77                 ady = y2 - y1;
78         }
79         else
80         {
81                 /* bottom to top */
82                 signy = -1;
83                 ady = y1 - y2;
84         }
85
86         x = x1;
87         y = y1;
88
89         if (adx > ady)
90         {
91                 /* X-major line (octants 1/4/5/8) */
92
93                 len = adx;
94                 e = -adx;
95                 while (len--)
96                 {
97                         /* Sanity check */
98                         ASSERT((x >= 0) && (x < bm->width) && (y >= 0) && (y < bm->height));
99                         BM_PLOT(bm, x, y);
100                         x += signx;
101                         e += ady;
102                         if (e >= 0)
103                         {
104                                 y += signy;
105                                 e -= adx;
106                         }
107                 }
108         }
109         else
110         {
111                 /* Y-major line (octants 2/3/6/7) */
112
113                 len = ady;
114                 e = -ady;
115                 while (len--)
116                 {
117                         /* Sanity check */
118                         ASSERT ((x >= 0) && (x < bm->width) && (y >= 0) && (y < bm->height));
119                         BM_PLOT(bm, x, y);
120                         y += signy;
121                         e += adx;
122                         if (e >= 0)
123                         {
124                                 x += signx;
125                                 e -= ady;
126                         }
127                 }
128         }
129 }
130
131 //! Helper routine for gfx_line().
132 static int gfx_findRegion(int x, int y, Rect *cr)
133 {
134         int code = 0;
135
136         if (y >= cr->ymax)
137                 code |= 1; /* below */
138         else if (y < cr->ymin)
139                 code |= 2; /* above */
140
141         if (x >= cr->xmax)
142                 code |= 4; /* right */
143         else if (x < cr->xmin)
144                 code |= 8; /* left */
145
146         return code;
147 }
148
149 /**
150  * Draw a sloped line segment.
151  *
152  * Draw a sloped line segment identified by the provided
153  * start and end coordinates on the bitmap \a bm.
154  *
155  * The line endpoints are clipped inside the current bitmap
156  * clipping rectangle using the Cohen-Sutherland algorithm,
157  * which is very fast.
158  *
159  * \note The point at coordinates \a x2 \a y2 is not drawn.
160  *
161  * \note This function does \b not update the current pen position.
162  *
163  * \todo Compute updated Bresenham error term.
164  */
165 void gfx_line(Bitmap *bm, coord_t x1, coord_t y1, coord_t x2, coord_t y2)
166 {
167 #if CONFIG_GFX_CLIPPING
168         int clip1 = gfx_findRegion(x1, y1, &bm->cr);
169         int clip2 = gfx_findRegion(x2, y2, &bm->cr);
170
171         /* Loop while there is at least one point outside */
172         while (clip1 | clip2)
173         {
174                 /* Check for line totally outside */
175                 if (clip1 & clip2)
176                         return;
177
178                 int c = clip1 ? clip1 : clip2;
179                 int x, y;
180
181                 if (c & 1) /* Below */
182                 {
183                         x = x1 + (x2 - x1) * (bm->cr.ymax - y1) / (y2 - y1);
184                         y = bm->cr.ymax - 1;
185                 }
186                 else if (c & 2) /* Above */
187                 {
188                         x = x1 + (x2 - x1) * (bm->cr.ymin - y1) / (y2 - y1);
189                         y = bm->cr.ymin;
190                 }
191                 else if (c & 4) /* Right */
192                 {
193                         y = y1 + (y2 - y1) * (bm->cr.xmax - x1) / (x2 - x1);
194                         x = bm->cr.xmax - 1;
195                 }
196                 else /* Left */
197                 {
198                         y = y1 + (y2 - y1) * (bm->cr.xmin - x1) / (x2 - x1);
199                         x = bm->cr.xmin;
200                 }
201
202                 if (c == clip1) /* First endpoint was clipped */
203                 {
204                         // TODO: adjust Bresenham error term
205                         //coord_t clipdx = ABS(x - x1);
206                         //coord_t clipdy = ABS(y - y1);
207                         //e += (clipdy * e2) + ((clipdx - clipdy) * e1);
208
209                         x1 = x;
210                         y1 = y;
211                         clip1 = gfx_findRegion(x1, y1, &bm->cr);
212                 }
213                 else /* Second endpoint was clipped */
214                 {
215                         x2 = x;
216                         y2 = y;
217                         clip2 = gfx_findRegion(x2, y2, &bm->cr);
218                 }
219         }
220 #endif /* CONFIG_GFX_CLIPPING */
221
222         gfx_lineUnclipped(bm, x1, y1, x2, y2);
223 }
224
225 /*!
226  * Move the current pen position to the specified coordinates.
227  *
228  * The pen position is used for drawing operations such as
229  * gfx_lineTo(), which can be used to draw polygons.
230  */
231 void gfx_moveTo(Bitmap *bm, coord_t x, coord_t y)
232 {
233         bm->penX = x;
234         bm->penY = y;
235 }
236
237 /*!
238  * Draw a line from the current pen position to the new coordinates.
239  *
240  * \note This function moves the current pen position to the
241  *       new coordinates.
242  *
243  * \sa gfx_line()
244  */
245 void gfx_lineTo(Bitmap *bm, coord_t x, coord_t y)
246 {
247         gfx_line(bm, bm->penX, bm->penY, x, y);
248         gfx_moveTo(bm, x, y);
249 }
250
251
252 /*!
253  * Draw the perimeter of an hollow rectangle.
254  *
255  * \note The bottom-right corner of the rectangle is drawn at (x2-1;y2-1).
256  * \note This function does \b not update the current pen position.
257  */
258 void gfx_rectDraw(Bitmap *bm, coord_t x1, coord_t y1, coord_t x2, coord_t y2)
259 {
260         /* Sort coords (needed for correct bottom-right semantics) */
261         if (x1 > x2) SWAP(x1, x2);
262         if (y1 > y2) SWAP(y1, y2);
263
264         /* Draw rectangle */
265         gfx_line(bm, x1,   y1,   x2-1, y1);
266         gfx_line(bm, x2-1, y1,   x2-1, y2-1);
267         gfx_line(bm, x2-1, y2-1, x1,   y2-1);
268         gfx_line(bm, x1,   y2-1, x1,   y1);
269 }
270
271
272 /*!
273  * Fill a rectangular area with \a color.
274  *
275  * \note The bottom-right border of the rectangle is not drawn.
276  *
277  * \note This function does \b not update the current pen position.
278  */
279 void gfx_rectFillC(Bitmap *bm, coord_t x1, coord_t y1, coord_t x2, coord_t y2, uint8_t color)
280 {
281         coord_t x, y;
282
283         /* Sort coords */
284         if (x1 > x2) SWAP(x1, x2);
285         if (y1 > y2) SWAP(y1, y2);
286
287 #if CONFIG_GFX_CLIPPING
288         /* Clip rect to bitmap clip region */
289         if (x1 < bm->cr.xmin)   x1 = bm->cr.xmin;
290         if (x2 < bm->cr.xmin)   x2 = bm->cr.xmin;
291         if (x1 > bm->cr.xmax)   x1 = bm->cr.xmax;
292         if (x2 > bm->cr.xmax)   x2 = bm->cr.xmax;
293         if (y1 < bm->cr.ymin)   y1 = bm->cr.ymin;
294         if (y2 < bm->cr.ymin)   y2 = bm->cr.ymin;
295         if (y1 > bm->cr.ymax)   y1 = bm->cr.ymax;
296         if (y2 > bm->cr.ymax)   y2 = bm->cr.ymax;
297 #endif /* CONFIG_GFX_CLIPPING */
298
299         /* NOTE: Code paths are duplicated for efficiency */
300         if (color) /* fill */
301         {
302                 for (x = x1; x < x2; x++)
303                         for (y = y1; y < y2; y++)
304                                 BM_PLOT(bm, x, y);
305         }
306         else /* clear */
307         {
308                 for (x = x1; x < x2; x++)
309                         for (y = y1; y < y2; y++)
310                                 BM_CLEAR(bm, x, y);
311         }
312 }
313
314
315 /*!
316  * Draw a filled rectangle.
317  *
318  * \note The bottom-right border of the rectangle is not drawn.
319  *
320  * \note This function does \b not update the current pen position.
321  */
322 void gfx_rectFill(Bitmap *bm, coord_t x1, coord_t y1, coord_t x2, coord_t y2)
323 {
324         gfx_rectFillC(bm, x1, y1, x2, y2, 0xFF);
325 }
326
327
328 /*!
329  * Clear a rectangular area.
330  *
331  * \note The bottom-right border of the rectangle is not cleared.
332  *
333  * \note This function does \b not update the current pen position.
334  */
335 void gfx_rectClear(Bitmap *bm, coord_t x1, coord_t y1, coord_t x2, coord_t y2)
336 {
337         gfx_rectFillC(bm, x1, y1, x2, y2, 0x00);
338 }
339
340
341 #if CONFIG_GFX_VCOORDS
342 /*!
343  * Imposta gli estremi del sistema di coordinate cartesiane rispetto
344  * al rettangolo di clipping della bitmap.
345  */
346 void gfx_setViewRect(Bitmap *bm, vcoord_t x1, vcoord_t y1, vcoord_t x2, vcoord_t y2)
347 {
348         ASSERT(x1 != x2);
349         ASSERT(y1 != y2);
350
351         bm->orgX    = x1;
352         bm->orgY    = y1;
353         bm->scaleX  = (vcoord_t)(bm->cr.xmax - bm->cr.xmin - 1) / (vcoord_t)(x2 - x1);
354         bm->scaleY  = (vcoord_t)(bm->cr.ymax - bm->cr.ymin - 1) / (vcoord_t)(y2 - y1);
355
356 /*      DB(kprintf("orgX = %f, orgY = %f, scaleX = %f, scaleY = %f\n",
357                 bm->orgX, bm->orgY, bm->scaleX, bm->scaleY);)
358 */
359 }
360
361
362 /*!
363  * Transform a coordinate from the current reference system to a
364  * pixel offset within the bitmap.
365  */
366 coord_t gfx_transformX(Bitmap *bm, vcoord_t x)
367 {
368         return bm->cr.xmin + (coord_t)((x - bm->orgX) * bm->scaleX);
369 }
370
371 /*!
372  * Transform a coordinate from the current reference system to a
373  * pixel offset within the bitmap.
374  */
375 coord_t gfx_transformY(Bitmap *bm, vcoord_t y)
376 {
377         return bm->cr.ymin + (coord_t)((y - bm->orgY) * bm->scaleY);
378 }
379
380
381 /*!
382  * Draw a line from (x1;y1) to (x2;y2).
383  */
384 void gfx_vline(Bitmap *bm, vcoord_t x1, vcoord_t y1, vcoord_t x2, vcoord_t y2)
385 {
386         gfx_line(bm,
387                 gfx_transformX(bm, x1), gfx_transformY(bm, y1),
388                 gfx_transformY(bm, x2), gfx_transformY(bm, y2));
389 }
390 #endif /* CONFIG_GFX_VCOORDS */