405 lines
8.8 KiB
C++
405 lines
8.8 KiB
C++
/**
|
|
* \file
|
|
* <!--
|
|
* This file is part of BeRTOS.
|
|
*
|
|
* Bertos is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* As a special exception, you may use this file as part of a free software
|
|
* library without restriction. Specifically, if other files instantiate
|
|
* templates or use macros or inline functions from this file, or you compile
|
|
* this file and link it with other files to produce an executable, this
|
|
* file does not by itself cause the resulting executable to be covered by
|
|
* the GNU General Public License. This exception does not however
|
|
* invalidate any other reasons why the executable file might be covered by
|
|
* the GNU General Public License.
|
|
*
|
|
* Copyright 2005 Develer S.r.l. (http://www.develer.com/)
|
|
*
|
|
* -->
|
|
*
|
|
* \author Massimiliano Corsini <chad@develer.com>
|
|
*
|
|
*
|
|
* \brief Low-level drawing routines.
|
|
*
|
|
* This file contains the implementation of the low-level drawing routines
|
|
* to draw fill rectangle, fill triangle and so on.
|
|
*
|
|
*/
|
|
|
|
/*#*
|
|
*#* $Log$
|
|
*#* Revision 1.1 2006/07/19 13:00:01 bernie
|
|
*#* Import into DevLib.
|
|
*#*
|
|
*#* Revision 1.10 2005/10/15 15:03:43 rasky
|
|
*#* Remove per-pixel clipping from line().
|
|
*#* Use clipLine() also for a-scope.
|
|
*#*
|
|
*#* Revision 1.9 2005/10/14 15:21:32 eldes
|
|
*#* Implement the cohen-sutherland clipping on the buffer
|
|
*#*
|
|
*#* Revision 1.8 2005/09/27 13:28:10 rasky
|
|
*#* Add clipping capabilities to line()
|
|
*#* Fix off-by-one computation of rectangles of drawing.
|
|
*#*
|
|
*#* Revision 1.7 2005/09/27 10:41:35 rasky
|
|
*#* Import line-drawing routine from Devlib
|
|
*#*
|
|
*#* Revision 1.6 2005/09/19 16:36:05 chad
|
|
*#* Fix doxygen autobrief
|
|
*#*
|
|
*#* Revision 1.5 2005/07/06 12:51:47 chad
|
|
*#* Make the fillRectangle() independent of the order of the points of the rectangle
|
|
*#*
|
|
*#* Revision 1.4 2005/06/17 15:06:36 chad
|
|
*#* Remove conversion warning
|
|
*#*
|
|
*#* Revision 1.3 2005/06/17 15:04:47 chad
|
|
*#* Add line clipping capability
|
|
*#*
|
|
*#* Revision 1.2 2005/06/15 14:04:43 chad
|
|
*#* Add line routine
|
|
*#*
|
|
*#* Revision 1.1 2005/06/15 13:34:34 chad
|
|
*#* Low-level drawing routines
|
|
*#*
|
|
*#*/
|
|
|
|
// Qt-specific headers
|
|
#include <qpoint.h>
|
|
|
|
|
|
/**
|
|
* Low-level routine to draw a line.
|
|
*
|
|
* This routine is based on the Bresenham Line-Drawing Algorithm.
|
|
*
|
|
* The \a stride represents the width of the image buffer.
|
|
* (\a x1, \a y1) are the coordinates of the starting point.
|
|
* (\a x2, \a y2) are the coordinates of the ending point.
|
|
*
|
|
* The line has no anti-alias, and clipping is not performed. The line
|
|
* must be fully contained in the buffer (use clipLine() if you need
|
|
* to clip it).
|
|
*/
|
|
void line(unsigned char *buf,
|
|
unsigned long bufw, unsigned long bufh, unsigned long stride,
|
|
int x1, int y1, int x2, int y2, unsigned char color)
|
|
{
|
|
int x, y, e, len, adx, ady, signx, signy;
|
|
|
|
if (x2 > x1)
|
|
{
|
|
/* left to right */
|
|
signx = +1;
|
|
adx = x2 - x1;
|
|
}
|
|
else
|
|
{
|
|
/* right to left */
|
|
signx = -1;
|
|
adx = x1 - x2;
|
|
}
|
|
|
|
if (y2 > y1)
|
|
{
|
|
/* top to bottom */
|
|
signy = +1;
|
|
ady = y2 - y1;
|
|
}
|
|
else
|
|
{
|
|
/* bottom to top */
|
|
signy = -1;
|
|
ady = y1 - y2;
|
|
}
|
|
|
|
x = x1;
|
|
y = y1;
|
|
|
|
if (adx > ady)
|
|
{
|
|
/* X-major line (octants 1/4/5/8) */
|
|
len = adx;
|
|
e = -adx;
|
|
while (len--)
|
|
{
|
|
/* Sanity check */
|
|
assert(y >= 0 && y < static_cast<int>(bufh) &&
|
|
x >= 0 && x < static_cast<int>(bufw));
|
|
buf[y * stride + x] = color;
|
|
x += signx;
|
|
e += ady;
|
|
if (e >= 0)
|
|
{
|
|
y += signy;
|
|
e -= adx;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Y-major line (octants 2/3/6/7) */
|
|
len = ady;
|
|
e = -ady;
|
|
while (len--)
|
|
{
|
|
/* Sanity check */
|
|
assert(y >= 0 && y < static_cast<int>(bufh) &&
|
|
x >= 0 && x < static_cast<int>(bufw));
|
|
buf[y * stride + x] = color;
|
|
y += signy;
|
|
e += adx;
|
|
if (e >= 0)
|
|
{
|
|
x += signx;
|
|
e -= ady;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Helper routine for clipLine().
|
|
static int region(int x, int y, int w, int h)
|
|
{
|
|
int code = 0;
|
|
|
|
if (y >= h)
|
|
code |= 1; // top
|
|
else if (y < 0)
|
|
code |= 2; // bottom
|
|
|
|
if (x >= w)
|
|
code |= 4; // right
|
|
else if (x < 0)
|
|
code |= 8; // left
|
|
|
|
return code;
|
|
}
|
|
|
|
/**
|
|
* Low-level routine to draw a line, clipped to the buffer extents.
|
|
*
|
|
* This routine executes the clipping, and then invokes line().
|
|
* Parameters are the same of line(). The clipping is performed
|
|
* using the Cohen-Sutherland algorithm, which is very fast.
|
|
*/
|
|
void clipLine(unsigned char *buf,
|
|
unsigned long w, unsigned long h, unsigned long stride,
|
|
int x1, int y1, int x2, int y2, unsigned char color)
|
|
{
|
|
int code1 = region(x1, y1, w, h);
|
|
int code2 = region(x2, y2, w, h);
|
|
|
|
// Loop while there is at least one point outside
|
|
while (code1 | code2)
|
|
{
|
|
// Check for line totally outside
|
|
if (code1 & code2)
|
|
return;
|
|
|
|
int c = code1 ? code1 : code2;
|
|
int x, y;
|
|
|
|
if (c & 1) // top
|
|
{
|
|
x = x1 + (x2 - x1) * (h - y1) / (y2 - y1);
|
|
y = h - 1;
|
|
}
|
|
else if (c & 2) //bottom
|
|
{
|
|
x = x1 + (x2 - x1) * -y1 / (y2 - y1);
|
|
y = 0;
|
|
}
|
|
else if (c & 4) //right
|
|
{
|
|
y = y1 + (y2 - y1) * (w - x1) / (x2 - x1);
|
|
x = w - 1;
|
|
}
|
|
else //left
|
|
{
|
|
y = y1 + (y2 - y1) * -x1 / (x2 - x1);
|
|
x = 0;
|
|
}
|
|
|
|
if (c == code1) // first endpoint was clipped
|
|
{
|
|
x1 = x; y1 = y;
|
|
code1 = region(x1, y1, w, h);
|
|
}
|
|
else //second endpoint was clipped
|
|
{
|
|
x2 = x; y2 = y;
|
|
code2 = region(x2, y2, w, h);
|
|
}
|
|
}
|
|
|
|
line(buf, w, h, stride, x1, y1, x2, y2, color);
|
|
}
|
|
|
|
|
|
/**
|
|
* Low-level routine to draw a filled rectangle.
|
|
*
|
|
* The triangle is filled with the given color.
|
|
*
|
|
* The \a stride represents the width of the image buffer.
|
|
* The points \a p1 and \a p2 are two opposite corners of the
|
|
* rectangle.
|
|
*/
|
|
void fillRectangle(unsigned char *buf, unsigned long stride,
|
|
QPoint p1, QPoint p2, unsigned char color)
|
|
{
|
|
QPoint ul; // upper-left corner
|
|
QPoint lr; // lower-right corner
|
|
|
|
if (p2.x() > p1.x())
|
|
{
|
|
ul.setX(p1.x());
|
|
lr.setX(p2.x());
|
|
}
|
|
else
|
|
{
|
|
ul.setX(p2.x());
|
|
lr.setX(p1.x());
|
|
}
|
|
|
|
if (p2.y() > p1.y())
|
|
{
|
|
ul.setY(p1.y());
|
|
lr.setY(p2.y());
|
|
}
|
|
else
|
|
{
|
|
ul.setY(p2.y());
|
|
lr.setY(p1.y());
|
|
}
|
|
|
|
int width = lr.x() - ul.x();
|
|
unsigned long offset = ul.x() + ul.y()*stride;
|
|
|
|
for (int h = ul.y(); h < lr.y(); h++)
|
|
{
|
|
memset(buf+offset, color, width);
|
|
offset += stride;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Low-level routines to draw a filled triangle.
|
|
*
|
|
* The triangle is filled with the given \a color.
|
|
* The \a stride represents the width of the image buffer (\a buf).
|
|
*
|
|
* The routine use fixed-point arithmetic.
|
|
*/
|
|
void fillTriangle(unsigned char* buf, unsigned long stride,
|
|
QPoint v1, QPoint v2, QPoint v3, unsigned char color)
|
|
{
|
|
int altezza[3];
|
|
|
|
// Sort by vertical coordinate
|
|
if (v1.y() > v2.y())
|
|
std::swap(v1, v2);
|
|
if (v1.y() > v3.y())
|
|
std::swap(v1, v3);
|
|
if (v2.y() > v3.y())
|
|
std::swap(v2, v3);
|
|
|
|
altezza[0] = v3.y() - v1.y();
|
|
if (!altezza[0])
|
|
return;
|
|
|
|
int sezioni = 2;
|
|
int sezione = 1;
|
|
|
|
buf += v1.y() * stride;
|
|
|
|
altezza[1] = v2.y() - v1.y();
|
|
altezza[2] = v3.y() - v2.y();
|
|
|
|
int sinistra = v1.x();
|
|
int destra = sinistra;
|
|
|
|
if (v1.y() == v2.y())
|
|
{
|
|
if (v1.x() < v2.x())
|
|
destra = v2.x();
|
|
else
|
|
sinistra = v2.x();
|
|
}
|
|
|
|
sinistra <<= 16;
|
|
destra <<= 16;
|
|
|
|
int stmp1, stmp2, stmp3;
|
|
|
|
stmp1 = (altezza[1] << 16) / altezza[0];
|
|
int lunghezza = stmp1 * (v3.x() - v1.x()) + ((v1.x() - v2.x()) << 16);
|
|
|
|
if (!lunghezza )
|
|
return;
|
|
|
|
int delta_sinistra[2];
|
|
int delta_destra[2];
|
|
|
|
stmp1 = ((v3.x() - v1.x()) << 16) / altezza[0];
|
|
|
|
if (altezza[1])
|
|
stmp2 = ((v2.x() - v1.x()) << 16) / altezza[1];
|
|
if (altezza[2])
|
|
stmp3 = ((v3.x() - v2.x()) << 16) / altezza[2];
|
|
|
|
if (lunghezza < 0) // Il secondo vertice ~J a destra
|
|
{
|
|
delta_sinistra[0] = stmp1;
|
|
delta_sinistra[1] = stmp1;
|
|
delta_destra[0] = stmp2;
|
|
delta_destra[1] = stmp3;
|
|
}
|
|
else // Il secondo vertice ~J a sinistra
|
|
{
|
|
delta_sinistra[0] = stmp2;
|
|
delta_sinistra[1] = stmp3;
|
|
delta_destra[0] = stmp1;
|
|
delta_destra[1] = stmp1;
|
|
}
|
|
|
|
int len2 = lunghezza;
|
|
|
|
do
|
|
{
|
|
while (altezza [sezione])
|
|
{
|
|
unsigned char* curpos = buf + ((sinistra )>> 16);
|
|
lunghezza = ((destra ) >> 16) - ((sinistra ) >> 16);
|
|
assert(lunghezza >= 0);
|
|
if (lunghezza)
|
|
memset(curpos, color, lunghezza);
|
|
buf += stride;
|
|
destra += delta_destra[sezione - 1];
|
|
sinistra += delta_sinistra[sezione - 1];
|
|
altezza[sezione]--;
|
|
}
|
|
if (len2 < 0)
|
|
destra = v2.x() << 16;
|
|
else
|
|
sinistra = v2.x() << 16;
|
|
sezione++;
|
|
} while (--sezioni);
|
|
}
|