488 lines
11 KiB
C
488 lines
11 KiB
C
#include <u.h>
|
|
#include <libc.h>
|
|
#include <draw.h>
|
|
#include <memdraw.h>
|
|
#include <memlayer.h>
|
|
|
|
enum
|
|
{
|
|
Arrow1 = 8,
|
|
Arrow2 = 10,
|
|
Arrow3 = 3,
|
|
};
|
|
|
|
#ifdef NOT
|
|
static
|
|
int
|
|
lmin(int a, int b)
|
|
{
|
|
if(a < b)
|
|
return a;
|
|
return b;
|
|
}
|
|
#endif
|
|
|
|
static
|
|
int
|
|
lmax(int a, int b)
|
|
{
|
|
if(a > b)
|
|
return a;
|
|
return b;
|
|
}
|
|
|
|
#ifdef NOTUSED
|
|
/*
|
|
* Rather than line clip, we run the Bresenham loop over the full line,
|
|
* and clip on each pixel. This is more expensive but means that
|
|
* lines look the same regardless of how the windowing has tiled them.
|
|
* For speed, we check for clipping outside the loop and make the
|
|
* test easy when possible.
|
|
*/
|
|
|
|
static
|
|
void
|
|
horline1(Memimage *dst, Point p0, Point p1, int srcval, Rectangle clipr)
|
|
{
|
|
int x, y, dy, deltay, deltax, maxx;
|
|
int dd, easy, e, bpp, m, m0;
|
|
uchar *d;
|
|
|
|
deltax = p1.x - p0.x;
|
|
deltay = p1.y - p0.y;
|
|
dd = dst->width*sizeof(ulong);
|
|
dy = 1;
|
|
if(deltay < 0){
|
|
dd = -dd;
|
|
deltay = -deltay;
|
|
dy = -1;
|
|
}
|
|
maxx = lmin(p1.x, clipr.max.x-1);
|
|
bpp = dst->depth;
|
|
m0 = 0xFF^(0xFF>>bpp);
|
|
m = m0 >> (p0.x&(7/dst->depth))*bpp;
|
|
easy = ptinrect(p0, clipr) && ptinrect(p1, clipr);
|
|
e = 2*deltay - deltax;
|
|
y = p0.y;
|
|
d = byteaddr(dst, p0);
|
|
deltay *= 2;
|
|
deltax = deltay - 2*deltax;
|
|
for(x=p0.x; x<=maxx; x++){
|
|
if(easy || (clipr.min.x<=x && clipr.min.y<=y && y<clipr.max.y))
|
|
*d ^= (*d^srcval) & m;
|
|
if(e > 0){
|
|
y += dy;
|
|
d += dd;
|
|
e += deltax;
|
|
}else
|
|
e += deltay;
|
|
d++;
|
|
m >>= bpp;
|
|
if(m == 0)
|
|
m = m0;
|
|
}
|
|
}
|
|
|
|
static
|
|
void
|
|
verline1(Memimage *dst, Point p0, Point p1, int srcval, Rectangle clipr)
|
|
{
|
|
int x, y, deltay, deltax, maxy;
|
|
int easy, e, bpp, m, m0, dd;
|
|
uchar *d;
|
|
|
|
deltax = p1.x - p0.x;
|
|
deltay = p1.y - p0.y;
|
|
dd = 1;
|
|
if(deltax < 0){
|
|
dd = -1;
|
|
deltax = -deltax;
|
|
}
|
|
maxy = lmin(p1.y, clipr.max.y-1);
|
|
bpp = dst->depth;
|
|
m0 = 0xFF^(0xFF>>bpp);
|
|
m = m0 >> (p0.x&(7/dst->depth))*bpp;
|
|
easy = ptinrect(p0, clipr) && ptinrect(p1, clipr);
|
|
e = 2*deltax - deltay;
|
|
x = p0.x;
|
|
d = byteaddr(dst, p0);
|
|
deltax *= 2;
|
|
deltay = deltax - 2*deltay;
|
|
for(y=p0.y; y<=maxy; y++){
|
|
if(easy || (clipr.min.y<=y && clipr.min.x<=x && x<clipr.max.x))
|
|
*d ^= (*d^srcval) & m;
|
|
if(e > 0){
|
|
x += dd;
|
|
d += dd;
|
|
e += deltay;
|
|
}else
|
|
e += deltax;
|
|
d += dst->width*sizeof(ulong);
|
|
m >>= bpp;
|
|
if(m == 0)
|
|
m = m0;
|
|
}
|
|
}
|
|
|
|
static
|
|
void
|
|
horliner(Memimage *dst, Point p0, Point p1, Memimage *src, Point dsrc, Rectangle clipr)
|
|
{
|
|
int x, y, sx, sy, deltay, deltax, minx, maxx;
|
|
int bpp, m, m0;
|
|
uchar *d, *s;
|
|
|
|
deltax = p1.x - p0.x;
|
|
deltay = p1.y - p0.y;
|
|
sx = drawreplxy(src->r.min.x, src->r.max.x, p0.x+dsrc.x);
|
|
minx = lmax(p0.x, clipr.min.x);
|
|
maxx = lmin(p1.x, clipr.max.x-1);
|
|
bpp = dst->depth;
|
|
m0 = 0xFF^(0xFF>>bpp);
|
|
m = m0 >> (minx&(7/dst->depth))*bpp;
|
|
for(x=minx; x<=maxx; x++){
|
|
y = p0.y + (deltay*(x-p0.x)+deltax/2)/deltax;
|
|
if(clipr.min.y<=y && y<clipr.max.y){
|
|
d = byteaddr(dst, Pt(x, y));
|
|
sy = drawreplxy(src->r.min.y, src->r.max.y, y+dsrc.y);
|
|
s = byteaddr(src, Pt(sx, sy));
|
|
*d ^= (*d^*s) & m;
|
|
}
|
|
if(++sx >= src->r.max.x)
|
|
sx = src->r.min.x;
|
|
m >>= bpp;
|
|
if(m == 0)
|
|
m = m0;
|
|
}
|
|
}
|
|
|
|
static
|
|
void
|
|
verliner(Memimage *dst, Point p0, Point p1, Memimage *src, Point dsrc, Rectangle clipr)
|
|
{
|
|
int x, y, sx, sy, deltay, deltax, miny, maxy;
|
|
int bpp, m, m0;
|
|
uchar *d, *s;
|
|
|
|
deltax = p1.x - p0.x;
|
|
deltay = p1.y - p0.y;
|
|
sy = drawreplxy(src->r.min.y, src->r.max.y, p0.y+dsrc.y);
|
|
miny = lmax(p0.y, clipr.min.y);
|
|
maxy = lmin(p1.y, clipr.max.y-1);
|
|
bpp = dst->depth;
|
|
m0 = 0xFF^(0xFF>>bpp);
|
|
for(y=miny; y<=maxy; y++){
|
|
if(deltay == 0) /* degenerate line */
|
|
x = p0.x;
|
|
else
|
|
x = p0.x + (deltax*(y-p0.y)+deltay/2)/deltay;
|
|
if(clipr.min.x<=x && x<clipr.max.x){
|
|
m = m0 >> (x&(7/dst->depth))*bpp;
|
|
d = byteaddr(dst, Pt(x, y));
|
|
sx = drawreplxy(src->r.min.x, src->r.max.x, x+dsrc.x);
|
|
s = byteaddr(src, Pt(sx, sy));
|
|
*d ^= (*d^*s) & m;
|
|
}
|
|
if(++sy >= src->r.max.y)
|
|
sy = src->r.min.y;
|
|
}
|
|
}
|
|
|
|
static
|
|
void
|
|
horline(Memimage *dst, Point p0, Point p1, Memimage *src, Point dsrc, Rectangle clipr)
|
|
{
|
|
int x, y, deltay, deltax, minx, maxx;
|
|
int bpp, m, m0;
|
|
uchar *d, *s;
|
|
|
|
deltax = p1.x - p0.x;
|
|
deltay = p1.y - p0.y;
|
|
minx = lmax(p0.x, clipr.min.x);
|
|
maxx = lmin(p1.x, clipr.max.x-1);
|
|
bpp = dst->depth;
|
|
m0 = 0xFF^(0xFF>>bpp);
|
|
m = m0 >> (minx&(7/dst->depth))*bpp;
|
|
for(x=minx; x<=maxx; x++){
|
|
y = p0.y + (deltay*(x-p0.x)+deltay/2)/deltax;
|
|
if(clipr.min.y<=y && y<clipr.max.y){
|
|
d = byteaddr(dst, Pt(x, y));
|
|
s = byteaddr(src, addpt(dsrc, Pt(x, y)));
|
|
*d ^= (*d^*s) & m;
|
|
}
|
|
m >>= bpp;
|
|
if(m == 0)
|
|
m = m0;
|
|
}
|
|
}
|
|
|
|
static
|
|
void
|
|
verline(Memimage *dst, Point p0, Point p1, Memimage *src, Point dsrc, Rectangle clipr)
|
|
{
|
|
int x, y, deltay, deltax, miny, maxy;
|
|
int bpp, m, m0;
|
|
uchar *d, *s;
|
|
|
|
deltax = p1.x - p0.x;
|
|
deltay = p1.y - p0.y;
|
|
miny = lmax(p0.y, clipr.min.y);
|
|
maxy = lmin(p1.y, clipr.max.y-1);
|
|
bpp = dst->depth;
|
|
m0 = 0xFF^(0xFF>>bpp);
|
|
for(y=miny; y<=maxy; y++){
|
|
if(deltay == 0) /* degenerate line */
|
|
x = p0.x;
|
|
else
|
|
x = p0.x + deltax*(y-p0.y)/deltay;
|
|
if(clipr.min.x<=x && x<clipr.max.x){
|
|
m = m0 >> (x&(7/dst->depth))*bpp;
|
|
d = byteaddr(dst, Pt(x, y));
|
|
s = byteaddr(src, addpt(dsrc, Pt(x, y)));
|
|
*d ^= (*d^*s) & m;
|
|
}
|
|
}
|
|
}
|
|
#endif /* NOTUSED */
|
|
|
|
static Memimage*
|
|
membrush(int radius)
|
|
{
|
|
static Memimage *brush;
|
|
static int brushradius;
|
|
|
|
if(brush==nil || brushradius!=radius){
|
|
freememimage(brush);
|
|
brush = allocmemimage(Rect(0, 0, 2*radius+1, 2*radius+1), memopaque->chan);
|
|
if(brush != nil){
|
|
memfillcolor(brush, DTransparent); /* zeros */
|
|
memellipse(brush, Pt(radius, radius), radius, radius, -1, memopaque, Pt(radius, radius), S);
|
|
}
|
|
brushradius = radius;
|
|
}
|
|
return brush;
|
|
}
|
|
|
|
static
|
|
void
|
|
discend(Point p, int radius, Memimage *dst, Memimage *src, Point dsrc, int op)
|
|
{
|
|
Memimage *disc;
|
|
Rectangle r;
|
|
|
|
disc = membrush(radius);
|
|
if(disc != nil){
|
|
r.min.x = p.x - radius;
|
|
r.min.y = p.y - radius;
|
|
r.max.x = p.x + radius+1;
|
|
r.max.y = p.y + radius+1;
|
|
memdraw(dst, r, src, addpt(r.min, dsrc), disc, Pt(0,0), op);
|
|
}
|
|
}
|
|
|
|
static
|
|
void
|
|
arrowend(Point tip, Point *pp, int end, int sin, int cos, int radius)
|
|
{
|
|
int x1, x2, x3;
|
|
|
|
/* before rotation */
|
|
if(end == Endarrow){
|
|
x1 = Arrow1;
|
|
x2 = Arrow2;
|
|
x3 = Arrow3;
|
|
}else{
|
|
x1 = (end>>5) & 0x1FF; /* distance along line from end of line to tip */
|
|
x2 = (end>>14) & 0x1FF; /* distance along line from barb to tip */
|
|
x3 = (end>>23) & 0x1FF; /* distance perpendicular from edge of line to barb */
|
|
}
|
|
|
|
/* comments follow track of right-facing arrowhead */
|
|
pp->x = tip.x+((2*radius+1)*sin/2-x1*cos); /* upper side of shaft */
|
|
pp->y = tip.y-((2*radius+1)*cos/2+x1*sin);
|
|
pp++;
|
|
pp->x = tip.x+((2*radius+2*x3+1)*sin/2-x2*cos); /* upper barb */
|
|
pp->y = tip.y-((2*radius+2*x3+1)*cos/2+x2*sin);
|
|
pp++;
|
|
pp->x = tip.x;
|
|
pp->y = tip.y;
|
|
pp++;
|
|
pp->x = tip.x+(-(2*radius+2*x3+1)*sin/2-x2*cos); /* lower barb */
|
|
pp->y = tip.y-(-(2*radius+2*x3+1)*cos/2+x2*sin);
|
|
pp++;
|
|
pp->x = tip.x+(-(2*radius+1)*sin/2-x1*cos); /* lower side of shaft */
|
|
pp->y = tip.y+((2*radius+1)*cos/2-x1*sin);
|
|
}
|
|
|
|
void
|
|
_memimageline(Memimage *dst, Point p0, Point p1, int end0, int end1, int radius, Memimage *src, Point sp, Rectangle clipr, int op)
|
|
{
|
|
/*
|
|
* BUG: We should really really pick off purely horizontal and purely
|
|
* vertical lines and handle them separately with calls to memimagedraw
|
|
* on rectangles.
|
|
*/
|
|
|
|
int hor;
|
|
int sin, cos, dx, dy, t;
|
|
Rectangle oclipr, r;
|
|
Point q, pts[10], *pp, d;
|
|
|
|
if(radius < 0)
|
|
return;
|
|
if(rectclip(&clipr, dst->r) == 0)
|
|
return;
|
|
if(rectclip(&clipr, dst->clipr) == 0)
|
|
return;
|
|
d = subpt(sp, p0);
|
|
if(rectclip(&clipr, rectsubpt(src->clipr, d)) == 0)
|
|
return;
|
|
if((src->flags&Frepl)==0 && rectclip(&clipr, rectsubpt(src->r, d))==0)
|
|
return;
|
|
/* this means that only verline() handles degenerate lines (p0==p1) */
|
|
hor = (abs(p1.x-p0.x) > abs(p1.y-p0.y));
|
|
/*
|
|
* Clipping is a little peculiar. We can't use Sutherland-Cohen
|
|
* clipping because lines are wide. But this is probably just fine:
|
|
* we do all math with the original p0 and p1, but clip when deciding
|
|
* what pixels to draw. This means the layer code can call this routine,
|
|
* using clipr to define the region being written, and get the same set
|
|
* of pixels regardless of the dicing.
|
|
*/
|
|
if((hor && p0.x>p1.x) || (!hor && p0.y>p1.y)){
|
|
q = p0;
|
|
p0 = p1;
|
|
p1 = q;
|
|
t = end0;
|
|
end0 = end1;
|
|
end1 = t;
|
|
}
|
|
|
|
if((p0.x == p1.x || p0.y == p1.y) && (end0&0x1F) == Endsquare && (end1&0x1F) == Endsquare){
|
|
r.min = p0;
|
|
r.max = p1;
|
|
if(p0.x == p1.x){
|
|
r.min.x -= radius;
|
|
r.max.x += radius+1;
|
|
}
|
|
else{
|
|
r.min.y -= radius;
|
|
r.max.y += radius+1;
|
|
}
|
|
oclipr = dst->clipr;
|
|
dst->clipr = clipr;
|
|
memimagedraw(dst, r, src, sp, memopaque, sp, op);
|
|
dst->clipr = oclipr;
|
|
return;
|
|
}
|
|
|
|
/* Hard: */
|
|
/* draw thick line using polygon fill */
|
|
icossin2(p1.x-p0.x, p1.y-p0.y, &cos, &sin);
|
|
dx = (sin*(2*radius+1))/2;
|
|
dy = (cos*(2*radius+1))/2;
|
|
pp = pts;
|
|
oclipr = dst->clipr;
|
|
dst->clipr = clipr;
|
|
q.x = ICOSSCALE*p0.x+ICOSSCALE/2-cos/2;
|
|
q.y = ICOSSCALE*p0.y+ICOSSCALE/2-sin/2;
|
|
switch(end0 & 0x1F){
|
|
case Enddisc:
|
|
discend(p0, radius, dst, src, d, op);
|
|
/* fall through */
|
|
case Endsquare:
|
|
default:
|
|
pp->x = q.x-dx;
|
|
pp->y = q.y+dy;
|
|
pp++;
|
|
pp->x = q.x+dx;
|
|
pp->y = q.y-dy;
|
|
pp++;
|
|
break;
|
|
case Endarrow:
|
|
arrowend(q, pp, end0, -sin, -cos, radius);
|
|
_memfillpolysc(dst, pts, 5, ~0, src, addpt(pts[0], mulpt(d, ICOSSCALE)), 1, 10, 1, op);
|
|
pp[1] = pp[4];
|
|
pp += 2;
|
|
}
|
|
q.x = ICOSSCALE*p1.x+ICOSSCALE/2+cos/2;
|
|
q.y = ICOSSCALE*p1.y+ICOSSCALE/2+sin/2;
|
|
switch(end1 & 0x1F){
|
|
case Enddisc:
|
|
discend(p1, radius, dst, src, d, op);
|
|
/* fall through */
|
|
case Endsquare:
|
|
default:
|
|
pp->x = q.x+dx;
|
|
pp->y = q.y-dy;
|
|
pp++;
|
|
pp->x = q.x-dx;
|
|
pp->y = q.y+dy;
|
|
pp++;
|
|
break;
|
|
case Endarrow:
|
|
arrowend(q, pp, end1, sin, cos, radius);
|
|
_memfillpolysc(dst, pp, 5, ~0, src, addpt(pts[0], mulpt(d, ICOSSCALE)), 1, 10, 1, op);
|
|
pp[1] = pp[4];
|
|
pp += 2;
|
|
}
|
|
_memfillpolysc(dst, pts, pp-pts, ~0, src, addpt(pts[0], mulpt(d, ICOSSCALE)), 0, 10, 1, op);
|
|
dst->clipr = oclipr;
|
|
return;
|
|
}
|
|
|
|
void
|
|
memimageline(Memimage *dst, Point p0, Point p1, int end0, int end1, int radius, Memimage *src, Point sp, int op)
|
|
{
|
|
_memimageline(dst, p0, p1, end0, end1, radius, src, sp, dst->clipr, op);
|
|
}
|
|
|
|
/*
|
|
* Simple-minded conservative code to compute bounding box of line.
|
|
* Result is probably a little larger than it needs to be.
|
|
*/
|
|
static
|
|
void
|
|
addbbox(Rectangle *r, Point p)
|
|
{
|
|
if(r->min.x > p.x)
|
|
r->min.x = p.x;
|
|
if(r->min.y > p.y)
|
|
r->min.y = p.y;
|
|
if(r->max.x < p.x+1)
|
|
r->max.x = p.x+1;
|
|
if(r->max.y < p.y+1)
|
|
r->max.y = p.y+1;
|
|
}
|
|
|
|
int
|
|
memlineendsize(int end)
|
|
{
|
|
int x3;
|
|
|
|
if((end&0x3F) != Endarrow)
|
|
return 0;
|
|
if(end == Endarrow)
|
|
x3 = Arrow3;
|
|
else
|
|
x3 = (end>>23) & 0x1FF;
|
|
return x3;
|
|
}
|
|
|
|
Rectangle
|
|
memlinebbox(Point p0, Point p1, int end0, int end1, int radius)
|
|
{
|
|
Rectangle r, r1;
|
|
int extra;
|
|
|
|
r.min.x = 10000000;
|
|
r.min.y = 10000000;
|
|
r.max.x = -10000000;
|
|
r.max.y = -10000000;
|
|
extra = lmax(memlineendsize(end0), memlineendsize(end1));
|
|
r1 = insetrect(canonrect(Rpt(p0, p1)), -(radius+extra));
|
|
addbbox(&r, r1.min);
|
|
addbbox(&r, r1.max);
|
|
return r;
|
|
}
|